15 udvalgte klassiske machine learning 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 forskellen mellem en modelparameter og en hyperparameter i superviseret læring?
I superviseret maskinlæring er modelparametre interne variabler, der læres direkte fra træningsdata via en optimeringsalgoritme (såsom gradient descent eller normalligninger). Eksempler inkluderer regressionsvægte og bias i lineære modeller eller opdelingsgrænser i beslutningstræer. I modsætning hertil er hyperparametre eksterne konfigurationsindstillinger, der specificeres før træning, og som styrer læringsprocessen, modelkapaciteten eller arkitekturen. De kan ikke læres direkte via standard minimering af træningstab, fordi optimeringen trivielt ville overfitte (f.eks. at sætte trædybden til uendelig). Eksempler inkluderer læringshastighed, regulariseringsstyrke (lambda/C), antallet af træer i en skov og maksimal trædybde. Hyperparametre finjusteres ved hjælp af valideringsdata eller krydsvalidering.
from sklearn.linear_model import Ridge
import numpy as np
X = np.array([[1.0], [2.0], [3.0]])
y = np.array([2.0, 4.0, 6.0])
# Hyperparameter: alpha (regularization strength set beforehand)
model = Ridge(alpha=1.0)
# Fitting optimizes internal parameters on training data
model.fit(X, y)
# Learned parameters
print(f"Weight (Parameter): {model.coef_[0]:.4f}")
print(f"Intercept (Parameter): {model.intercept_:.4f}")
2Hvilke antagelser gør Ordinary Least Squares (OLS) lineær regression, og hvordan vil residualdiagnostik afsløre antagelsesovertrædelser?
Ordinary Least Squares (OLS) lineær regression bygger på flere kerneantagelser:
1. Linearitet: Forholdet mellem prædiktorer og udfald er lineært i parametrene.
2. Uafhængighed af fejl: Observationer og residualfejl er gensidigt uafhængige (ingen autokorrelation).
3. Homoskedasticitet: Fejlled har konstant varians på tværs af alle niveauer af prædiktorer.
4. Normalitet af residualer: Fejlled er normalfordelte (påkrævet for gyldige konfidensintervaller og hypotesetests).
5. Ingen multikollinearitet: Prædiktorer er ikke lineært afhængige (designmatrixen har fuld kolonnerang).
Residualdiagnostik afslører overtrædelser som følger:
- Plot af residualer mod fittede værdier: Krumning eller ikke-tilfældige mønstre afslører ikke-linearitet; en tragt- eller vifteform afslører heteroskedasticitet (ikke-konstant varians).
- Normal Q-Q-plot: Systematisk afvigelse fra den lige diagonal linje (f.eks. S-kurver eller tunge haler) afslører ikke-normalitet.
- Plot af residualer mod rækkefølge/tid: Systematiske tendenser eller cykliske mønstre afslører autokorrelere fejl.
- Plot for leverage / Cook's distance: Identificerer outliers med høj leverage eller indflydelsesrige punkter, der uforholdsmæssigt forskydder den tilpassede model.
import numpy as np
import statsmodels.api as sm
np.random.seed(42)
X = np.linspace(1, 10, 50)
# Quadratic underlying pattern creates a linearity violation
y = 2 * X + 0.5 * (X ** 2) + np.random.normal(0, 2, 50)
X_with_const = sm.add_constant(X)
model = sm.OLS(y, X_with_const).fit()
residuals = model.resid
print(f"Mean Residual: {np.mean(residuals):.4f}")
print(f"Curvature in residuals indicates model misspecification.")
3Hvordan modellerer logistisk regression binær klassifikation, og hvad er sigmoidefunktionens rolle?
Logistisk regression modellerer binær klassifikation ved at estimere den posteriore klasse-sandsynlighed $P(Y=1|X)$. For at sikre, at de forudsagte sandsynligheder forbliver inden for intervallet $(0, 1)$, modellerer logistisk regression log-odds (logit) for den positive klasse som en lineær funktion af input: $\ln\left(\frac{p}{1-p}\right) = w^T x + b$. Sigmoide (logistiske) funktion, $\sigma(z) = \frac{1}{1 + e^{-z}}$, fungerer som link-funktionen, der monotont mapper enhver realværdi lineær score $z = w^T x + b \in (-\infty, +\infty)$ til en gyldig sandsynlighed $p \in (0, 1)$. Diskrete klassebeslutninger træffes ved at anvende en beslutningstærskel $\tau$ (typisk 0.5): $\hat{y} = 1$ hvis $P(Y=1|X) \ge \tau$, ellers $0$. Fordi $\sigma(z) = 0.5$ forekommer præcis når $z = 0$, er beslutningsgrænsen i feature-rummet den lineære hyperplan $w^T x + b = 0$, hvilket gør standard logistisk regression til en lineær klassifikator.
import numpy as np
def sigmoid(z):
return 1 / (1 + np.exp(-z))
w = np.array([1.5, -2.0])
b = 0.5
x = np.array([2.0, 1.0])
z = np.dot(w, x) + b
prob = sigmoid(z)
threshold = 0.5
pred = int(prob >= threshold)
print(f"Log-odds (z): {z:.2f}")
print(f"Probability: {prob:.4f}")
print(f"Class Prediction: {pred}")
4Hvad er L2-regularisering, og hvordan ændrer Ridge-regression objektivfunktionen og koefficientestimaterne?
L2-regularisering (Ridge-regression) tilføjer en straf proportional med summen af de kvadrerede vægte til den almindelige mindste kvadraters (OLS) tabsfunkton:
$$\min_w \|y - Xw\|_2^2 + \lambda \|w\|_2^2$$
Analytisk modificerer Ridge normal-ligningerne ved at tilføje $\lambda I$ til Gram-matrixen før inversion:
$$w_{\text{ridge}} = (X^T X + \lambda I)^{-1} X^T y$$
Væsentlige konsekvenser for objektivfunktionen og koefficientestimaterne:
1. **Krympning**: Koefficienter krympes mod nul proportionalt med feature-varians og korrelation, hvilket reducerer modelkompleksiteten uden at tvinge dem til præcis nul.
2. **Multikollinearitet og Invertibilitet**: Når features er kollineære eller $p > N$, er $X^T X$ singulær eller dårligt konditioneret. Tilføjelse af $\lambda I$ sikrer, at $(X^T X + \lambda I)$ er strengt positiv definit og invertibel, hvilket stabiliserer parameterestimaterne.
3. **Bias-varians-afvejning**: Øgning af $\lambda$ introducerer en bevidst bias i koefficientestimaterne, samtidig med at variansen reduceres betydeligt, hvilket resulterer i en lavere forventet generaliseringsfejl på usete data.
4. **Krav til Feature-skalering**: Fordi straffefunktionen behandler alle vægte ens, ville features med større skala blive regulariseret uforholdsmæssigt. Features skal standardiseres (nul middelværdi, enhedsvarians) før tilpasning.
import numpy as np
def ridge_regression(X, y, alpha):
X_std = (X - np.mean(X, axis=0)) / np.std(X, axis=0)
n_features = X_std.shape[1]
I = np.eye(n_features)
beta = np.linalg.inv(X_std.T @ X_std + alpha * I) @ X_std.T @ y
return beta
X = np.array([[1.0, 2.0], [2.0, 4.1], [3.0, 5.9], [4.0, 8.2]])
y = np.array([2.1, 4.0, 6.2, 8.1])
weights = ridge_regression(X, y, alpha=1.0)
print('Ridge Weights:', weights)
5Hvordan opdeler et beslutningstræ (decision tree) rekursivt feature-rummet (feature space), og hvilke kriterier bruges til at vælge klassifikationsopdelinger?
Et beslutningstræ opdeler feature-rummet gennem en top-down, grådig algoritme kaldet **rekursiv binær opdeling (recursive binary partitioning)**. Startende ved rodnoden (root node) med alle træningsdata (training data) søger algoritmen over alle features og mulige tærskelværdier for at finde den enkelte akse-justerede opdeling ($X_j \le t$), der maksimerer reduktionen i urenhed. Datasættet opdeles i to børneknudepunkter (child nodes), og denne procedure anvendes rekursivt på hvert børneknudepunkt, indtil et stopkriterium (f.eks. maksimal dybde, minimum antal prøver per blad eller rene noder) er nået. Fordi opdelinger evaluerer én feature ad gangen mod en tærskel, er de resulterende beslutningsgrænser ortogonale hyperplaner (akse-justerede rektangulære områder i feature-rummet).
Til at evaluere og vælge den bedste opdeling i klassifikationstræer bruges to hovedkriterier for urenhed:
1. **Gini-urenhed (Gini Impurity) (brugt i CART)**: Måler sandsynligheden for, at en tilfældigt valgt prøve ville blive fejlklassificeret, hvis den blev mærket tilfældigt i henhold til nodens klassefordeling. For $K$ klasser med proportioner $p_k$: $$I_G = 1 - \sum_{k=1}^K p_k^2$$
2. **Entropi og Information Gain (brugt i ID3, C4.5)**: Entropi måler usikkerheden i en node: $H = -\sum_{k=1}^K p_k \log_2(p_k)$. Opdelingen vælges for at maksimere **Information Gain**, som er forældernodens entropi minus den vægtede gennemsnitlige entropi af børneknudepunkterne: $$IG = H(\text{parent}) - \sum_{c \in \{\text{left, right}\}} \frac{N_c}{N} H(c)$$
Begge metrikker når 0, når en node er fuldstændig ren (alle prøver tilhører en enkelt klasse) og når deres maksimum, når klasserne er ligeligt fordelt.
6Hvad er k-nærmeste naboer, og hvordan udfører den forudsigelser for klassifikation og regression?
k-Nearest Neighbors (kNN) er en ikke-parametrisk, instansbaseret (doven) overvåget læringsalgoritme. Den træner ikke en eksplicit parametrisk model; i stedet gemmer den træningsdatasættet og udfører alle beregninger under inferens. Forudsigelses-workflow: 1. Afstandsberegning: Når en forespørgselsinstans evalueres, beregner algoritmen dens afstand til alle gemte træningsinstanser ved hjælp af en specificeret metrik (såsom Euklidisk, Manhattan eller Minkowski-afstand). 2. Valg af Naboer: Den vælger de $k$ træningsinstanser med de mindste afstande til forespørgselsinstansen. 3. Aggregering: - Klassifikation: Den tildeler klassen via flertalsafstemning (modus) blandt de $k$ naboer (eller afstands-vægtet afstemning). - Regression: Den forudsiger det kontinuerlige mål ved at tage det lokale gennemsnit (middelværdi eller median) af de $k$ naboers målværdier (eller afstands-vægtet gennemsnit). Da afstandsberegninger afhænger direkte af feature-skalaer, er feature-normalisering eller standardisering afgørende for at forhindre features med stor størrelsesorden i at dominere afstandsberegninger.
7Angiv den naive Bayes' betingede uafhængighedsantagelse, og forklar hvorfor naiv Bayes stadig kan fungere godt, når den overtrædes.
Den naive Bayes' betingede uafhængighedsantagelse fastslår, at givet klasselabel Y = y, er alle features X_1, X_2, ..., X_d gensidigt uafhængige: P(X_1, ..., X_d | Y = y) = \prod_{j=1}^d P(X_j | Y = y). Ved hjælp af Bayes' sætning er den posteriori sandsynlighed: P(Y = y | X) \propto P(Y = y) \prod_{j=1}^d P(X_j | Y = y), hvor P(Y = y) er klassens apriori sandsynlighed, og P(X_j | Y = y) er den klassebetingede likelihood (f.eks. Gaussisk for kontinuerlige features, Multinomial for tællinger). Naiv Bayes fungerer ofte godt i praksis på trods af overtrædelser af uafhængighed, fordi klassificering er afhængig af argmax-beslutningsreglen (argmax_y P(Y=y | X)) snarere end nøjagtig sandsynlighedskalibrering. Selvom feature-korrelationer får forudsagte sandsynligheder til at blive overkonfidente eller forvrængede, bevarer den korrekte klasse ofte den højeste relative rangering. Så længe korrelationen ikke vender rangeringen af klasse-likelihoods, forbliver 0-1 klassificeringsbeslutningen nøjagtig.
from sklearn.naive_bayes import GaussianNB
import numpy as np
X = np.array([[1.0, 1.1], [1.2, 0.9], [-1.0, -1.2], [-0.8, -1.1]])
y = np.array([1, 1, 0, 0])
model = GaussianNB()
model.fit(X, y)
# Prediction uses argmax over class posterior scores
print("Predicted class:", model.predict([[1.1, 1.0]]))
8Udled eller forklar den lukkede form-OLS-løsning, og angiv, hvornår den eksisterer entydigt.
OLS (Ordinary Least Squares)-objektivet minimerer summen af kvadrerede residualer: $S(\beta) = \|y - X\beta\|^2 = (y - X\beta)^T (y - X\beta) = y^T y - 2\beta^T X^T y + \beta^T X^T X \beta$. Sætter vi gradienten med hensyn til $\beta$ til nul: $$\nabla_\beta S(\beta) = -2 X^T y + 2 X^T X \beta = 0 \implies X^T X \beta = X^T y$$ Dette er normal-ligningerne. Når $X^T X$ er ikke-singulær (invertibel), er den unikke lukkede form-løsning: $$\hat{\beta} = (X^T X)^{-1} X^T y$$ Geometrisk repræsenterer $\hat{y} = X\hat{\beta} = X(X^T X)^{-1} X^T y = H y$ den ortogonale projektion af målvektoren $y$ på designmatricen $X$'s kolonnerum, hvor $H$ er projektions-(hat)-matricen. Løsningen eksisterer entydigt, hvis og kun hvis $X^T X$ er invertibel, hvilket kræver, at den $N \times P$ designmatrix $X$ har fuld kolonne-rang ($Rank(X) = P$). Dette kræver $N \ge P$ og ingen præcis multikollinearitet (ingen feature er en lineær kombination af andre). Hvis $X$ er rang-defekt, er $X^T X$ singulær, hvilket fører til uendeligt mange løsninger, ofte løst via regularisering eller Moore-Penrose pseudoinversen $X^+ y$.
import numpy as np
# Design matrix X (with intercept column) and target y
X = np.array([[1, 1], [1, 2], [1, 3], [1, 4]])
y = np.array([2.1, 3.9, 6.2, 8.0])
# Normal equations: (X^T X)^(-1) X^T y
beta_hat = np.linalg.inv(X.T @ X) @ X.T @ y
H = X @ np.linalg.inv(X.T @ X) @ X.T
y_hat = H @ y
print(f"Beta: {beta_hat}")
print(f"Predictions: {y_hat}")
9Hvad er maksimum likelihood-estimering (MLE), og hvordan fører det til den logistiske regression cross-entropy objektivfunktion?
Maksimum Likelihood-estimering (MLE) er en metode til estimering af modelparametre $\theta$ ved at vælge værdier, der maksimerer likelihood $L(\theta) = P(\mathcal{D}|\theta)$ af det observerede datasæt. I binær logistisk regression modelleres hver etiket $y_i \in \{0, 1\}$ som en uafhængig Bernoulli-stokastisk variabel betinget af $x_i$, med succes-sandsynlighed $p_i = \sigma(w^T x_i + b)$. Sandsynlighedsmassefunktionen for observation $i$ er $P(y_i|x_i) = p_i^{y_i} (1 - p_i)^{1 - y_i}$. Antagende uafhængige og identisk fordelte (i.i.d.) stikprøver, er den fælles likelihood:
$$L(w, b) = \prod_{i=1}^N p_i^{y_i} (1 - p_i)^{1 - y_i}$$
At tage den naturlige logaritme konverterer produktet til en beregningsmæssigt håndterbar sum af log-likelihoods:
$$\ell(w, b) = \sum_{i=1}^N \left[ y_i \ln(p_i) + (1 - y_i) \ln(1 - p_i) \right]$$
Da optimeringsalgoritmer standardmæssigt er formuleret som minimeringsproblemer, negerer vi log-likelihood og normaliserer med stikprøvestørrelse $N$, hvilket giver Negative Log-Likelihood (NLL), som er præcis den Binære Cross-Entropy (log loss) objektivfunktion:
$$J(w, b) = -\frac{1}{N} \sum_{i=1}^N \left[ y_i \ln(p_i) + (1 - y_i) \ln(1 - p_i) \right]$$
Denne objektivfunktion er konveks med hensyn til de lineære logits/vægte, så passende numeriske løsere optimerer et globalt objektiv. Strikt konveksitet og en endelig, unik MLE kræver yderligere betingelser såsom tilstrækkelig feature-rang, regularisering og ingen perfekt klasseseparation.
10Hvordan optimerer gradientnedstigning et klassisk ML (Machine Learning) mål, og hvordan påvirker læringshastighed, konvergens og konveksitet træningen?
Gradientnedstigning minimerer en empirisk tabsfunkion ved iterativt at opdatere modelparametre i den modsatte retning af målfunktionens gradient med hensyn til disse parametre: $\theta_{t+1} = \theta_t - \eta \nabla L(\theta_t)$. Nøglefaktorer, der påvirker træningen, inkluderer:
1. **Læringshastighed ($\eta$):** Kontrollerer skridtstørrelsen. Hvis den er indstillet for lavt, er konvergensen ekstremt langsom, og træningen kan gå i stå. Hvis den er indstillet for højt, vil opdateringerne skyde over minimum, hvilket forårsager oscillation eller numerisk divergens.
2. **Konvergens:** Bestemmes ved at overvåge stoppekriterier som en lille gradientnorm ($||\nabla L(\theta)|| \le \epsilon$), minimal parameterforskydning eller tabet udflades (plateauing) på tværs af efterfølgende iterationer.
3. **Konveksitet:** I konvekse målfunktioner (f.eks. standard OLS lineær regression eller logistisk regression) er ethvert lokalt minimum garanteret at være et globalt minimum, hvilket tillader gradientnedstigning at konvergere pålideligt med passende skridtstørrelser. I ikke-konvekse målfunktioner (f.eks. neurale netværk med flere lag) indeholder tabslandskabet flere lokale minima, saddelpunkter og plateauer, hvilket gør den endelige løsning følsom over for initialisering.
4. **Optimering vs. Generalisering:** Konvergens på træningstabet afspejler optimeringssucces, mens valideringstab evaluerer generalisering. At opnå et lavt træningstab med høj valideringsfejl indikerer overfitting snarere end en optimeringsfejl.
import numpy as np
def gradient_descent(X, y, lr=0.01, max_iters=1000, tol=1e-6):
n_samples, n_features = X.shape
theta = np.zeros(n_features)
prev_loss = float('inf')
for i in range(max_iters):
predictions = X @ theta
error = predictions - y
loss = (1 / (2 * n_samples)) * np.dot(error, error)
if abs(prev_loss - loss) < tol:
print(f'Converged at iteration {i}')
break
prev_loss = loss
grad = (1 / n_samples) * (X.T @ error)
theta -= lr * grad
return theta
11Sammenlign L1-, L2- og ElasticNet-regularisering med hensyn til sparsitet, korrelerede features og praktisk modelvalg.
L1 (Lasso), L2 (Ridge) og ElasticNet-regularisering adskiller sig i strafformulering, begrænsningsgeometri, sparsitet og håndtering af korrelerede prædiktorer: 1. Sparsitet og geometri: - L1 anvender en absolutværdistraf ($\lambda \|w\|_1$). Dens begrænsningsgrænse er en diamant/polytop med skarpe hjørner på koordinatakserne. Når `loss`-konturerne skærer disse hjørner, drives vægte til præcis nul, hvilket udfører automatisk feature-udvælgelse. - L2 anvender en kvadratisk euklidisk normstraf ($\lambda \|w\|_2^2$). Dens begrænsningsgrænse er en glat hypersfære uden hjørner, der krymper vægte mod nul asymptotisk, men sjældent sætter dem til præcis nul. 2. Korrelerede features: - Under stærk kollinearitet har L1 en tendens til arbitrært at vælge én feature fra en gruppe af korrelerede prædiktorer og sætte de resterende koefficienter til nul, hvilket resulterer i ustabile estimater på tværs af gensampling. - L2 bevarer alle korrelerede features, fordeler vægtene blandt dem og krymper dem sammen. 3. ElasticNet: - Kombinerer begge straffe: $\lambda_1 \|w\|_1 + \lambda_2 \|w\|_2^2$ (ofte parameteriseret med $\alpha$ og $l_1\_\text{ratio}$). - Leverer sparsiteten og feature-udvælgelsen fra Lasso, samtidig med at den bevarer Ridge's grupperingseffekt, hvor klynger af korrelerede prædiktorer vælges sammen. Den er særligt nyttig, når $p > N$ eller under alvorlig multikollinearitet.
12Hvad er forskellen mellem Ridge-regression, Principal Component Regression og Partial Least Squares på et højt niveau?
Ridge-regression, Principal Component Regression (PCR) og Partial Least Squares (PLS) er tre lineære teknikker, der anvendes til at håndtere multikollinearitet og høj dimensionalitet, men de adskiller sig i, hvordan de reducerer varians, og om reduktionen er kontinuerlig eller overvåget: 1. Ridge-regression: Bevarer alle originale $p$ features og anvender kontinuerlig indskrumpning af koefficientstørrelser via en L2-straf. Den konstruerer ikke lavere-dimensionale latente komponenter eller kasserer feature-dimensioner; i stedet indskrumper den variansen langs lav-egenværdiretninger af $X^T X$. 2. Principal Component Regression (PCR): En totrins, uovervåget dimensionsreduktionsmetode. Den anvender først Principal Component Analysis (PCA) strengt på prædiktormatricen $X$ for at finde ortogonale retninger med maksimal varians, bevarer de øverste $k$ hovedkomponenter og tilpasser en OLS (Ordinary Least Squares) regression på disse $k$ komponenter. Fordi PCA ignorerer målvariablen $y$, risikerer PCR at kassere komponenter, der har lav varians i $X$, men høj prædiktiv kraft for $y$. 3. Partial Least Squares (PLS): En overvåget dimensionsreduktionsmetode. Den konstruerer $k$ ortogonale latente komponenter ved at finde lineære kombinationer af $X$, der maksimerer kovariansen mellem $X$ og respons $y$. Ved eksplicit at inkorporere målinformation identificerer PLS komponenter, der forklarer både feature-varians og respons-variation.
from sklearn.linear_model import Ridge, LinearRegression
from sklearn.decomposition import PCA
from sklearn.cross_decomposition import PLSRegression
from sklearn.pipeline import make_pipeline
# 1. Ridge: Regularized full feature space
ridge = Ridge(alpha=1.0)
# 2. PCR: Unsupervised PCA followed by OLS
pcr = make_pipeline(PCA(n_components=2), LinearRegression())
# 3. PLS: Supervised latent component projection and regression
pls = PLSRegression(n_components=2)
13Hvordan optimerer moderne gradient boosting-implementeringer som XGBoost, LightGBM og CatBoost træning, eller hvordan håndterer de tabeldata (tabular features) forskelligt?
Moderne GBDT (Gradient Boosting Decision Trees)-rammeværker adskiller sig markant i deres split-finding-algoritmer, trævækststrategier og håndtering af tabeldata/kategoriske features:
1. XGBoost: Traditionelt baseret på præcis greedy eller omtrentlig quantile sketch split-finding (og senere Fast Hist), bruger level-wise (dybde-baseret) trævækst og håndterer manglende værdier ved at lære en optimal standardgreneretning under split-søgning.
2. LightGBM: Bruger histogram-baseret split-finding (binning af kontinuerlige features i diskrete buckets, typisk 256), leaf-wise (bedst-først) trævækst for hurtigere tabreduktion, Gradient-based One-Side Sampling (GOSS) for at bevare instanser med store gradienter, mens instanser med små gradienter subsamples, og Exclusive Feature Bundling (EFB) til at flette gensidigt eksklusive sparse features. For kategoriske variabler finder den optimale splits ved at sortere kategoriske histogram-bins ($O(K \log K)$).
3. CatBoost: Bruger oblivious (symmetriske) beslutningstræer, hvor alle noder på en given dybde deler præcis samme split, hvilket muliggør hurtig vektoriseret CPU/GPU-scoring. Dens primære innovation er Ordered Target Statistics og ordered boosting, som beregner target-statistikker over tilfældige permutationer af træningsdata for at forhindre target leakage og prediction shift.
14Hvordan ville du beslutte, om en brugerdefineret tabsfunkion er passende for en gradient boosting model under asymmetriske forretningsomkostninger?
At beslutte, om en brugerdefineret tabsfunkion skal implementeres i gradient boosting under asymmetriske forretningsomkostninger, kræver en evaluering af, om asymmetrien kan håndteres downstream via sandsynlighedskalibrering og tærskeljustering, eller om den fundamentalt ændrer optimeringslandskabet under træinduktion:
1. **Tærskeljustering vs. Brugerdefineret tabsfunkion**: For klassifikationsopgaver med asymmetriske fejlomkostninger (f.eks. falske negativer, der koster $10\times$ falske positiver), er standard krydsentropi en egnet scoringsregel, der sigter mod at estimere posteriori sandsynligheder $P(y=1|x)$. Kalibrering bør dog kontrolleres og, om nødvendigt, korrigeres på valideringsdata. At ændre klassifikationsbeslutningstærsklen baseret på forretningsomkostningsmatrix $\tau = \frac{C_{FP}}{C_{FP} + C_{FN}}$ eller anvende stikprøvevægte er ofte renere og undgår brugerdefinerede afledte. Men for asymmetrisk regression (f.eks. asymmetrisk pinball tabsfunkion for lagerbehov) eller ikke-lineære forretningsstraffe, hvor standardmålsætninger ikke kan guide split-finding, er en brugerdefineret tabsfunkion berettiget.
2. **Matematiske krav til GBDT**: I andenordens boostere (XGBoost, LightGBM) kræver en brugerdefineret tabsfunkion $L(y, \hat{y})$ normalt beregnelige førsteordens gradienter ($g_i = \partial L / \partial \hat{y}_i$) og gyldige andenordens krumning/Hessian-værdier ($h_i = \partial^2 L / \partial \hat{y}_i^2$) for splitgevinst og blad-vægt beregninger ($w^* = -\sum g_i / (\sum h_i + \lambda)$). Hessians bør være ikke-negative eller sikkert approksimeret/klippet for numerisk stabilitet; nogle implementeringer understøtter førsteordens eller approksimerede målsætninger, så kravet er framework-specifikt. Ikke-differentierbare eller diskontinuerlige forretningsmetrikker bør erstattes med glatte surrogat-approksimationer (f.eks. Huberiserede eller log-cosh-varianter).
import numpy as np
import xgboost as xgb
def asymmetric_mse_objective(preds, dtrain):
labels = dtrain.get_label()
residual = preds - labels
# Penalize underestimation (residual < 0) 5x more heavily than overestimation
penalty = np.where(residual < 0, 5.0, 1.0)
grad = 2.0 * penalty * residual
hess = 2.0 * penalty
return grad, hess
# Usage:
# model = xgb.train(params, dtrain, obj=asymmetric_mse_objective)
15Hvad er LambdaMART, og hvordan tilpasser den gradient boosting til learning-to-rank mål?
LambdaMART er en Learning-to-Rank (LTR) algoritme, der kombinerer MART (Multiple Additive Regression Trees / Gradient Boosting) med LambdaRank-rammeværket. I ranking afhænger mål-metrikker som NDCG (Normalized Discounted Cumulative Gain) og MAP (Mean Average Precision) af diskret sorteringsrækkefølge (rangeringer), hvilket gør dem "flade" næsten overalt og ikke-differentiable i forhold til kontinuerlige modelscorer. LambdaMART omgår dette ved at konstruere virtuelle gradienter, kaldet 'lambda gradienter' ($\lambda_{ij}$), for par af elementer $(i, j)$ inden for den samme forespørgsel. Den grundlæggende parvise gradient kommer fra et logistisk tab på scoreforskelle ($s_i - s_j$). LambdaMART skalerer denne gradient med den nøjagtige ændring i den ønskede rankingmetrik ($|\Delta \text{NDCG}_{ij}|$), der ville opstå, hvis positionerne for dokument $i$ og dokument $j$ blev byttet om: $$\lambda_{ij} = \frac{-\sigma}{1 + e^{\sigma(s_i - s_j)}} |\Delta \text{NDCG}_{ij}|$$ For hvert individuelle dokument $i$ beregnes nettogradienten ved at aggregere parvise lambdaer på tværs af alle par, der involverer dokument $i$: $\lambda_i = \sum_{j: j \succ i} \lambda_{ij} - \sum_{k: i \succ k} \lambda_{ki}$. Standard regressionstræer i boosting-ensemblet tilpasser derefter disse sammensatte lambda-gradienter pr. dokument ved hver boosting-iteration, hvilket direkte optimerer listevise ranking-metrikker.
import lightgbm as lgb
import numpy as np
# Simulated query-grouped data: 2 queries with 3 docs each
X = np.random.randn(6, 10)
y = np.array([3, 1, 0, 2, 0, 1]) # Relevance grades (0-3)
group = [3, 3] # Query group sizes
train_data = lgb.Dataset(X, label=y, group=group)
params = {
'objective': 'lambdarank',
'metric': 'ndcg',
'ndcg_eval_at': [1, 3],
'learning_rate': 0.1,
'n_estimators': 50
}
ranker = lgb.train(params, train_data)