# Top 25 pytań rekrutacyjnych z Data Science w 2026 roku

> Kompleksowy przegląd 25 najczęstszych pytań na rozmowach kwalifikacyjnych dla data scientistów w 2026 roku — od statystyki i ML po SQL, inżynierię cech i architekturę transformerów.

- Published: 2026-04-05
- Updated: 2026-04-05
- Author: SharpSkill
- Tags: data-science, interview, machine-learning
- Reading time: 12 min

---

Rynek pracy dla data scientistów pozostaje jednym z najbardziej konkurencyjnych w branży technologicznej. Rekruterzy i hiring managerowie oczekują od kandydatów nie tylko znajomości algorytmów, ale również solidnych podstaw statystycznych, umiejętności pracy z danymi nieustrukturyzowanymi oraz rozumienia pułapek, które mogą zepsuć nawet najlepiej wyglądający model. Poniższy zestaw 25 pytań odzwierciedla tematy najczęściej poruszane na rozmowach kwalifikacyjnych w 2026 roku — zarówno w startupach, jak i w dużych korporacjach technologicznych.

> Przed rozmoŵą warto przejrzeć nie tylko teorię, ale przede wszystkim przygotować własne implementacje kluczowych konceptu. Rekruterzy coraz częściej proszą o napisanie kodu na żywo — znajomość gotowych bibliotek to za mało.

## 1. Czym różni się podejście bayesowskie od częstościowego (frequentist)?

Podejście częstościowe traktuje prawdopodobieństwo jako graniczną częstość zdarzeń w nieskończonych powtórzeniach eksperymentu. Parametry modelu są stałe, choć nieznane — estymuje się je na podstawie danych. Przedział ufności (confidence interval) opisuje procedurę, która w 95% powtórzeń eksperymentu zawierałaby prawdziwy parametr — nie prawdopodobieństwo, że konkretny przedział go zawiera.

Podejście bayesowskie traktuje parametry jako zmienne losowe z rozkładem a priori, który aktualizuje się po obserwacji danych zgodnie z twierdzeniem Bayesa. Wynikiem jest rozkład a posteriori — przedział kredybilności (credible interval) można interpretować bezpośrednio jako zakres, w którym parametr leży z zadanym prawdopodobieństwem.

```python
# bayesian_vs_frequentist.py
import numpy as np
from scipy import stats

# Frequentist: confidence interval for a mean
data = np.array([23.1, 25.4, 22.8, 24.9, 23.7, 25.1, 24.3])
ci = stats.t.interval(0.95, df=len(data)-1, loc=np.mean(data), scale=stats.sem(data))
print(f"95% CI (frequentist): [{ci[0]:.2f}, {ci[1]:.2f}]")

# Bayesian: posterior with conjugate prior (Normal-Normal)
prior_mean, prior_var = 24.0, 4.0  # prior belief
data_mean, data_var = np.mean(data), np.var(data, ddof=1) / len(data)
# Posterior parameters (conjugate update)
post_var = 1 / (1/prior_var + 1/data_var)
post_mean = post_var * (prior_mean/prior_var + data_mean/data_var)
post_ci = stats.norm.interval(0.95, loc=post_mean, scale=np.sqrt(post_var))
print(f"95% credible interval (Bayesian): [{post_ci[0]:.2f}, {post_ci[1]:.2f}]")
```

## 2. Jak działa test dwumianowy (binomial test) i kiedy go stosować?

Test dwumianowy służy do weryfikacji hipotezy o parametrze sukcesu rozkładu dwumianowego. Stosuje się go, gdy dane przyjmują jedną z dwóch wartości (sukces/porażka) i chce się sprawdzić, czy obserwowana proporcja istotnie różni się od wartości oczekiwanej.

Przykład: testowanie, czy moneta jest uczciwa po zaobserwowaniu 8 orłów w 10 rzutach.

```python
# binomial_test.py
from scipy import stats

# Two-sided binomial test: is the coin fair?
result = stats.binomtest(k=8, n=10, p=0.5, alternative='two-sided')
print(f"p-value: {result.pvalue:.4f}")  # 0.1094 (two-sided)
print(f"Reject H0 at alpha=0.05? {result.pvalue < 0.05}")  # False
```

P-wartość wynosi ~0.109, co oznacza brak podstaw do odrzucenia hipotezy o uczciwej monecie przy poziomie istotności 0.05. Ważne rozróżnienie: brak odrzucenia H0 nie jest równoznaczny z jej potwierdzeniem.

## 3. Jakie są strategie obsługi brakujących danych?

Brakujące dane można podzielić na trzy kategorie mechanizmów: MCAR (Missing Completely At Random), MAR (Missing At Random) i MNAR (Missing Not At Random). Wybór strategii imputacji zależy od diagnozy mechanizmu.

Najczęstsze strategie to:
- **Imputacja medianą/średną** — szybka, ale niszczy korelacje między zmiennymi
- **Imputacja KNN** — zachowuje lokalną strukturę danych
- **Imputacja iteracyjna (MICE)** — modeluje każdą zmienną jako funkcję pozostałych
- **Dodanie wskaźnika braków** — zachowuje informację o samym wzorcu brakujących danych

```python
# missing_data_strategies.py
import pandas as pd
from sklearn.impute import KNNImputer, SimpleImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

df = pd.DataFrame({
    'age': [25, 30, None, 45, None, 38],
    'income': [50000, None, 70000, 90000, 60000, None],
    'score': [85, 90, 78, None, 88, 92]
})

# Strategy 1: KNN imputation (preserves local structure)
knn_imp = KNNImputer(n_neighbors=2)
df_knn = pd.DataFrame(knn_imp.fit_transform(df), columns=df.columns)

# Strategy 2: Iterative imputation (MICE-like, models each feature)
iter_imp = IterativeImputer(max_iter=10, random_state=42)
df_iter = pd.DataFrame(iter_imp.fit_transform(df), columns=df.columns)

# Strategy 3: Add missingness indicator (preserves signal in the pattern)
df['income_missing'] = df['income'].isna().astype(int)
print(df_knn.round(1))
```

## 4. Czym jest target encoding i jak zapobiec wyciekowi danych?

Target encoding zastępuje wartości kategoryczne średną zmiennej docelowej dla danej kategorii. Jest szczególnie skuteczny przy zmiennych z dużą kardynalnością (wiele unikalnych wartości), gdzie one-hot encoding tworzyłby setki kolumn.

Główne zagrożenie to wyciek danych (data leakage) — jeśli encoding oblicza się na całym zbiorze przed walidacją krzyżową, model widzi informacje z zestawu testowego. Rozwiązaniem jest enkodowanie wewnątrz pętli cross-validation:

```python
# target_encoding.py
import pandas as pd
import numpy as np
from sklearn.model_selection import KFold

def target_encode_kfold(df, col, target, n_splits=5):
    """Target encoding with K-fold regularization to prevent leakage."""
    encoded = pd.Series(index=df.index, dtype=float)
    global_mean = df[target].mean()
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)

    for train_idx, val_idx in kf.split(df):
        # Compute means only from training fold
        means = df.iloc[train_idx].groupby(col)[target].mean()
        encoded.iloc[val_idx] = df.iloc[val_idx][col].map(means)

    # Fill categories unseen in training fold with global mean
    encoded.fillna(global_mean, inplace=True)
    return encoded

df = pd.DataFrame({
    'city': ['Paris', 'Lyon', 'Paris', 'Marseille', 'Lyon', 'Paris',
             'Marseille', 'Lyon', 'Paris', 'Marseille'],
    'hired': [1, 0, 1, 0, 1, 1, 0, 0, 1, 1]
})
df['city_encoded'] = target_encode_kfold(df, 'city', 'hired')
print(df[['city', 'city_encoded', 'hired']])
```

## 5. Jakich metryk używać przy niezbalansowanych klasach?

Dokładność (accuracy) jest myłącą metryką przy silnie niezbalansowanych zbiorach — model przewidujący zawsze klasę większościową osiąga 95% accuracy przy stosunku 95:5, nie ucząc się niczego użytecznego.

Zalecane metryki to:
- **Precision i Recall** — szczególnie istotne, gdy koszty błędów I i II rodzaju są różne
- **F1-score** — harmoniczna średnia precision i recall
- **ROC AUC** — miara zdolności rankingowej modelu, niezależna od progu decyzyjnego
- **Average Precision (AUPRC)** — pole pod krzywą precision-recall, bardziej informatywne przy silnej niezbalansowaniu

```python
# imbalanced_metrics.py
from sklearn.metrics import (
    classification_report, precision_recall_curve,
    average_precision_score, roc_auc_score
)
import numpy as np

# Simulated predictions on imbalanced data
np.random.seed(42)
y_true = np.array([0]*950 + [1]*50)  # 95/5 imbalance
y_scores = np.random.beta(2, 5, 1000)  # predicted probabilities
y_scores[y_true == 1] += 0.3  # positive class scores slightly higher
y_scores = np.clip(y_scores, 0, 1)
y_pred = (y_scores > 0.5).astype(int)

print(classification_report(y_true, y_pred, digits=3))
print(f"ROC AUC: {roc_auc_score(y_true, y_scores):.3f}")
print(f"Average Precision (AUPRC): {average_precision_score(y_true, y_scores):.3f}")
```

## 6. Co to jest wyciek danych (data leakage) i jak mu zapobiegać?

Wyciek danych następuje, gdy informacje z zestawu testowego lub ze zmiennej docelowej przenikają do procesu uczenia modelu, powodując sztucznie zawyżone wyniki walidacji. Model osiąga doskonałe wyniki na zbiorze testowym, ale zawodzi w produkcji.

Najczęstsze przyczyny wycieku:
- Skalowanie lub imputacja obliczana na całym zbiorze przed podziałem na train/test
- Zmienne zawierające informacje z przyszłości (leakage temporalny)
- Zmienne bezpośrednio skorelowane ze zmienną docelową po czasie zdarzenia

Rozwiązaniem jest enkapsulacja wszystkich kroków preprocessingu w obiekcie Pipeline:

```python
# leakage_prevention.py
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

X = np.random.randn(1000, 10)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

# WRONG: fit scaler on all data, then cross-validate
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # leakage: test fold info in scaling

# CORRECT: pipeline ensures preprocessing fits only on training folds
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
    ('model', GradientBoostingClassifier(n_estimators=100, random_state=42))
])
scores = cross_val_score(pipeline, X, y, cv=5, scoring='roc_auc')
print(f"AUC (no leakage): {scores.mean():.3f} +/- {scores.std():.3f}")
```

## 7. Jak działa mechanizm self-attention w transformerach?

Mechanizm self-attention pozwala każdemu tokenowi sekwencji zwrócić uwagę na wszystkie inne tokeny, ucząc się kontekstowych zależności. Dla każdego tokenu tworzone są trzy wektory: Query (Q), Key (K) i Value (V) — przez projekcje liniowe wejścia.

Oceny uwagi obliczane są jako iloczyn skalarny Q i K, skalowany przez pierwiastek z wymiaru kluczy (d_k), a następnie normalizowany funkcją softmax. Wynik mnoży się przez V, uzyskując reprezentację uwzględniającą kontekst całej sekwencji. Skalowanie przez pierwiastek z d_k zapobiega zanikaniu gradientów przy dużych wymiarach.

```python
# self_attention.py
import torch
import torch.nn.functional as F

def self_attention(x, d_k):
    """Scaled dot-product self-attention from scratch."""
    # x shape: (batch_size, seq_len, d_model)
    batch_size, seq_len, d_model = x.shape

    # Linear projections for Q, K, V
    W_q = torch.randn(d_model, d_k) * 0.1
    W_k = torch.randn(d_model, d_k) * 0.1
    W_v = torch.randn(d_model, d_k) * 0.1

    Q = x @ W_q  # (batch, seq_len, d_k)
    K = x @ W_k
    V = x @ W_v

    # Scaled dot-product attention
    scores = Q @ K.transpose(-2, -1) / (d_k ** 0.5)  # (batch, seq_len, seq_len)
    weights = F.softmax(scores, dim=-1)  # attention weights
    output = weights @ V  # (batch, seq_len, d_k)

    return output, weights

# Example: 1 batch, 4 tokens, 8-dim embeddings
x = torch.randn(1, 4, 8)
out, attn = self_attention(x, d_k=8)
print(f"Output shape: {out.shape}")    # (1, 4, 8)
print(f"Attention weights:\n{attn[0].detach().numpy().round(3)}")
```

## 8. Jak znaleźć drugi najwyższy wynik w SQL?

Zapytania o drugi (lub n-ty) najwyższy rekord to klasyczny sprawdzian znajomości SQL. Rekruterzy cenią rozwiązania działające poprawnie przy duplikatach wartości i z podziałem na grupy (np. per departament).

```sql
-- second_highest_salary.sql
-- Approach: correlated subquery counting distinct higher salaries
SELECT d.department_name, e.employee_name, e.salary
FROM employees e
JOIN departments d ON e.department_id = d.id
WHERE (
    SELECT COUNT(DISTINCT e2.salary)
    FROM employees e2
    WHERE e2.department_id = e.department_id
      AND e2.salary > e.salary
) = 1
ORDER BY d.department_name;
```

Podejście z podzapytaniem korelowanym jest przenośne między silnikami baz danych. Alternatywnie można użyć funkcji okna `DENSE_RANK()` z klauzulą `QUALIFY` (BigQuery, Snowflake) lub wyrażeń CTE — warto znać obie wersje.

## 9. Czym różnią się map, apply i transform w bibliotece pandas?

Trzy metody służą do stosowania funkcji na danych w pandas, lecz działają na różnych poziomach abstrakcji:

- **map** — operacja element-wise wyłącznie na obiektach Series; służy do podstawiania wartości ze słownika lub przekształceń skalarnych
- **apply** — stosuje dowolną funkcję wzdłuż osi DataFrame lub na elementach Series; elastyczny, ale wolniejszy od wektoryzowanych operacji
- **transform** — jak apply w kontekście groupby, ale zwraca obiekt o tym samym kształcie co wejście; przydatny do broadcastowania statystyk grupowych

```python
# pandas_operations.py
import pandas as pd

df = pd.DataFrame({
    'team': ['A', 'A', 'B', 'B', 'A'],
    'score': [10, 20, 30, 40, 50]
})

# map: element-wise on Series
df['team_upper'] = df['team'].map({'A': 'Alpha', 'B': 'Beta'})

# apply: arbitrary function per row
df['score_label'] = df['score'].apply(lambda x: 'high' if x > 25 else 'low')

# transform: group-level, same shape output (broadcasts back)
df['team_mean'] = df.groupby('team')['score'].transform('mean')
df['score_normalized'] = df.groupby('team')['score'].transform(
    lambda x: (x - x.mean()) / x.std()
)
print(df)
```

## 10. Jak interpretować wartości SHAP?

Wartości SHAP (SHapley Additive exPlanations) wywodzą się z teorii gier kooperacyjnych. Każda wartość SHAP dla danej cechy i obserwacji reprezentuje wkład tej cechy w odchylenie predykcji od globalnej średniej modelu.

Globalne znaczenie cech oblicza się jako średną wartość bezwzględną SHAP po wszystkich obserwacjach. W przeciwieństwie do feature importance opartego na nieczystosći węzłów drzewa, SHAP jest spójny i addytywny — spełnia matematyczne aksjomaty sprawiedliwego podziału wkładu.

```python
# feature_importance_shap.py
import shap
import xgboost as xgb
from sklearn.datasets import make_classification

# Generate synthetic dataset
X, y = make_classification(n_samples=1000, n_features=10,
                           n_informative=5, random_state=42)

# Train XGBoost model
model = xgb.XGBClassifier(n_estimators=100, random_state=42, eval_metric='logloss')
model.fit(X, y)

# SHAP explanation
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X)

# Global importance: mean absolute SHAP value per feature
import numpy as np
importance = np.abs(shap_values).mean(axis=0)
for i in np.argsort(importance)[::-1]:
    print(f"Feature {i}: {importance[i]:.4f}")
```

## 11. Co to jest kompromis bias-variance (bias-variance tradeoff)?

Błąd generalizacji modelu rozkłada się na trzy składowe: bias (systematyczny błąd wynikający z uproszczeń modelu), wariancja (wrażliwość na fluktuacje danych treningowych) oraz nieredukowany szum danych.

Modele o wysokim biasie — przykładem jest regresja liniowa stosowana do nieliniowych zależności — underfitują: systematycznie chybiają niezależnie od rozmiaru zbioru treningowego. Modele o wysokiej wariancji — np. głębokie drzewa decyzyjne bez regularyzacji — overfitują: doskonale dopasowują dane treningowe, ale nie generalizują na nowych danych. Regularyzacja, przycinanie drzew (pruning), dropout oraz metody ensemble to główne narzędzia zarządzania tym kompromisem.

## 12. Jak działa gradient boosting i czym różni się od random forest?

Random forest buduje drzewa decyzyjne niezależnie — każde na losowej próbie bootstrapowej i losowym podzbiorze cech — a predykcję uśrednia (technika bagging). Redukuje wariancję, lecz nie bias poszczególnych drzew.

Gradient boosting buduje drzewa sekwencyjnie. Każde kolejne drzewo uczy się na residuałach poprzedniego — formalnie minimalizuje funkcję straty w przestrzeni funkcji metodą gradientu. Redukuje zarówno bias, jak i wariancję, ale jest bardziej wrażliwy na overfitting i wymaga starannego doboru hiperparametrów: learning rate, głębokości drzew i współczynnika subsampling. Popularne implementacje to XGBoost, LightGBM i CatBoost.

## 13. Czym jest regularyzacja L1 i L2 oraz kiedy którą stosować?

Regularyzacja L1 (Lasso) dodaje do funkcji straty karę proporcjonalną do sumy wartości bezwzględnych wag modelu. Generuje rozwiązania rzadkie (sparse) — część wag zeruje się, realizując automatyczną selekcję cech. Przydatna w scenariuszach, gdy zakłada się, że większość cech jest nieistotna.

Regularyzacja L2 (Ridge) penalizuje sumę kwadratów wag. Nie zeruje wag, ale redukuje je równomiernie, dobrze radząc sobie z multikolinealnością. Rozwiązanie analityczne istnieje zawsze — brak problemów z osobliwością macierzy Hessego.

Elastic Net łączy obie kary za pomocą parametru mieszającego alfa. Stosowana przy dużej liczbie wzajemnie skorelowanych cech, gdy sama Lasso jest niestabilna.

## 14. Jak przeprowadzić poprawną walidację krzyżową dla szeregów czasowych?

Standardowa k-fold cross-validation przetasowuje dane losowo. Przy szeregach czasowych prowadzi to do wycieku — model trenuje na danych z przyszłości względem foldu testowego, przez co wyniki walidacji są zbyt optymistyczne.

Poprawne podejście to time-series split z expanding window lub sliding window: zbiór treningowy zawsze poprzedza w czasie zbiór walidacyjny. Scikit-learn udostępnia `TimeSeriesSplit`, który implementuje expanding window. Warto ustawić parametr `gap` między foldem treningowym a testowym, aby unikać wycieków wynikających z autokorelacji między sąsiednimi próbkami.

## 15. Co to jest Principal Component Analysis (PCA) i kiedy warto go stosować?

PCA to technika redukcji wymiarowości, która przekształca cechy na ortogonalne składowe główne — liniowe kombinacje oryginalnych zmiennych — w kolejności malejącej wyjaśnianej wariancji. Pierwsza składowa wyjaśnia maksymalną wariancję, każda kolejna jest ortogonalna do poprzednich.

PCA stosuje się przed algorytmami wrażliwymi na przekleństwo wymiarowości, do wizualizacji w 2D/3D (w połączeniu z t-SNE lub UMAP), do usuwania szumu przez rzutowanie na podprzestrzeń głównych składowych oraz jako preprocessing przed klasteryzacją. Ograniczenia: PCA jest metodą liniową, wrażliwą na skalę (wymaga uprzedniej standaryzacji) i trudną do interpretacji po transformacji przestrzeni cech.

## 16. Jak działa algorytm k-means i jakie są jego ograniczenia?

Algorytm k-means minimalizuje sumaryczną sumę kwadratów odległości punktów od centroidów przypisanych klastrów (inercję). Iteruje naprzemiennie: przypisuje punkty do najbliższego centroidu (krok E), a następnie aktualizuje centroidy jako środki ciężkości przypisanych punktów (krok M). Algorytm zbiega do lokalnego, nie globalnego minimum.

Główne ograniczenia: zakłada kuliste klastry o podobnej gęstości i rozmiarze; jest wrażliwy na inicjalizację (rozwiązanie: k-means++ z mądrym inicjowaniem centroidów); jest wrażliwy na wartości odstające; wymaga wcześniejszego określenia liczby klasterów k. Dla złożonych kształtów klastrów lepsze są algorytmy DBSCAN (wykrywa klastry dowolnego kształtu i identyfikuje szum) lub Gaussian Mixture Models (miękkie przypisanie, klastry eliptyczne).

## 17. Czym jest oversampling i undersampling przy niezbalansowanych danych?

Przy silnie niezbalansowanych klasach sam dobór metryk to za mało — często konieczna jest korekta na poziomie danych lub algorytmu.

Undersampling losowo usuwa przykłady klasy większościowej, zmniejszając rozmiar zbioru treningowego. Prosta i szybka metoda, jednak traci informację zawartą w usuniętych próbkach.

Oversampling zwiększa reprezentację klasy mniejszościowej. SMOTE (Synthetic Minority Over-sampling Technique) generuje syntetyczne próbki przez interpolację między istniejącymi przykładami mniejszościowymi w przestrzeni cech — bardziej efektywne niż proste powielanie. Alternatywą algorytmiczną jest parametr `class_weight='balanced'` w scikit-learn, skalujący karę za błędy proporcjonalnie do odwrotności częstości klas.

## 18. Na czym polega różnica między modelem generatywnym a dyskryminatywnym?

Modele dyskryminatywne uczą się bezpośrednio rozkładu warunkowego P(Y|X) — granicy decyzyjnej między klasami. Przykłady: regresja logistyczna, SVM, sieci neuronowe klasyfikujące. Zazwyczaj osiągają wyższą dokładność klasyfikacji przy wystarczającej ilości danych.

Modele generatywne uczą się wspólnego rozkładu P(X, Y) = P(X|Y) × P(Y), modelując mechanizm generowania danych dla każdej klasy. Przykłady: Naive Bayes, Gaussian Mixture Models, GAN, VAE. Pozwalają na generowanie nowych próbek, lepiej działają przy małych zbiorach danych i umożliwiają wykrywanie anomalii przez ocenę prawdopodobieństwa przykładu.

## 19. Jak działa algorytm backpropagation?

Backpropagation to algorytm efektywnego obliczania gradientów funkcji straty względem wszystkich parametrów sieci neuronowej, wykorzystujący regułę łańcuchową (chain rule) rachunku różniczkowego.

Przepływ obliczeń przebiega w dwóch krokach: forward pass — obliczenie wyjścia sieci i wartości funkcji straty na podstawie bieżących wag; backward pass — propagacja gradientów od warstwy wyjściowej do wejściowej, aktualizując gradient każdej warstwy jako iloczyn gradientu z wyższej warstwy i lokalnej pochodnej aktywacji. Kluczowa optymalizacja: dynamiczne grafy obliczeniowe (jak w PyTorch) umożliwiają cache'owanie aktywacji z forward pass, unikając redundantnych obliczeń w backward pass.

## 20. Czym jest dropout i jak zapobiega overfittingowi?

Dropout to technika regularyzacji, która podczas treningu losowo zeruje aktywacje neuronów z prawdopodobieństwem p (typowo 0.2–0.5). W praktyce każdy mini-batch trenuje efektywnie inną, losowo zubożoną architekturę sieci.

Mechanizm zapobiegania overfittingowi: sieć nie może polegać na żadnym konkretnym neuronie (co-adaptation), co zmusza ją do uczenia redundantnych i bardziej ogólnych reprezentacji. Podczas inferencji dropout jest wyłączony, a aktywacje skalowane przez czynnik (1 - p) — lub wagi trenowane przez 1/(1-p), zależnie od implementacji (inverted dropout). W głębszych warstwach konwolucyjnych dropout jest mniej skuteczny — tam lepsze rezultaty osiąga batch normalization.

## 21. Co to jest attention mechanism i czym różni się self-attention od cross-attention?

Mechanizm uwagi (attention) pozwala modelowi dynamicznie ważyć różne części wejścia przy generowaniu każdego elementu wyjścia. Zastąpił rekurencyjne przetwarzanie w LSTM i GRU, umożliwiając równoległe obliczenia na całej sekwencji.

Self-attention: wektory query, key i value pochodzą z tej samej sekwencji — tokeny rozmawiają ze sobą wewnątrz jednej sekwencji (np. w enkoderze transformera modelu BERT). Cross-attention: query pochodzi z jednej sekwencji (np. dekodera), natomiast key i value z innej (np. enkodera) — mechanizm łączący reprezentacje dwóch sekwencji, kluczowy w architekturach seq2seq stosowanych w tłumaczeniu maszynowym i generowaniu tekstu.

## 22. Jak ewaluować model regresji?

Podstawowe metryki ewaluacji modeli regresji:

- **MAE (Mean Absolute Error)** — średnia bezwzględna różnica między predykcją a wartością rzeczywistą; odporna na wartości odstające, intuicyjna interpretacja
- **MSE (Mean Squared Error)** — penalizuje duże błędy kwadratowo; różniczkowalna wszędzie, standardowa w optymalizacji
- **RMSE** — pierwiastek MSE, wyrażony w tej samej jednostce co zmienna docelowa
- **R²** — frakcja wyjaśnionej wariancji (zakres 0–1, wyższe wartości lepsze); porównuje model z prostą średnią
- **MAPE** — procentowy błąd bezwzględny; niestabilny przy wartościach bliskich zeru

Wybór metryki zależy od kontekstu biznesowego: przy wartościach odstających preferuje się MAE lub Huber loss; przy porównaniu modeli na różnych zbiorach danych — MAPE lub znormalizowane RMSE.

## 23. Czym jest feature store i dlaczego jest istotny w produkcyjnym ML?

Feature store to scentralizowane repozytorium cech, obliczanych i zarządzanych w spójny sposób na potrzeby wielu modeli uczenia maszynowego. Rozwiązuje fundamentalny problem niespojności między środowiskiem treningowym a produkcyjnym (training-serving skew) — jedną z najczęstszych przyczyn degradacji jakości modeli po wdrożeniu.

Kluczowe funkcje: offline store dla historycznych cech (trening i backtesting), online store dla cech o niskim opóźnieniu (inferencja w czasie rzeczywistym), wersjonowanie cech i modeli, rejestr metadanych oraz możliwość ponownego użycia cech przez wiele modeli. Popularne rozwiązania to Feast (open-source), Tecton, Hopsworks i Vertex AI Feature Store.

## 24. Co to jest MLOps i jakie problemy rozwiązuje?

MLOps (Machine Learning Operations) to zestaw praktyk i narzędzi łączących rozwój modeli ML z ich wdrażaniem i utrzymaniem w produkcji, analogicznie do roli DevOps w inżynierii oprogramowania.

Główne wyzwania adresowane przez MLOps:
- **Reprodukowalność** — śledzenie eksperymentów, wersjonowanie danych i kodu (MLflow, DVC, Weights & Biases)
- **Continuous Training** — automatyczne retrenowanie modeli przy dryftowaniu danych wejściowych
- **Monitoring** — wykrywanie data drift i model drift w produkcji w czasie rzeczywistym
- **CI/CD dla ML** — automatyzacja testowania i wdrażania modeli przez pipelines i strategie canary deployment
- **Feature consistency** — zapewnienie spójności inżynierii cech między trenowaniem a serwowaniem

## 25. Jak wykryć i reagować na data drift w produkcji?

Data drift (covariate shift) następuje, gdy rozkład danych wejściowych w produkcji zmienia się względem rozkładu danych treningowych. Concept drift to zmiana samej relacji między wejściem a wyjściem — P(Y|X) jest inne niż w momencie trenowania.

Metody detekcji dryftu:
- **Statystyczne testy**: test Kołmogorowa-Smirnowa dla zmiennych ciągłych, Population Stability Index (PSI), chi-kwadrat dla zmiennych kategorycznych
- **Monitoring dystrybucji**: śledzenie percentyli, średnych i odsetka wartości null per feature w czasie
- **Monitoring wydajności**: spadek mierzalnych metryk biznesowych (CTR, konwersje, precyzja oznaczeń) jako pośredni sygnał degradacji modelu

Strategia reagowania zależy od diagnozy przyczyny: przy sezonowym lub cyklicznym drifcie — modele regularnie retrenowane na świeżych danych lub time-based instance weighting; przy trwałej zmianie struktury danych — przebudowanie procesu feature engineering i potencjalnie zmiana architektury modelu.

## Podsumowanie

Przygotowanie do rozmowy kwalifikacyjnej z data science wymaga opanowania szerokiego spektrum zagadnień: od fundamentów statystycznych i inżynierii cech, przez ewaluację modeli i obsługę niezbalansowanych danych, po architekturę transformerów i praktyki produkcyjnego MLOps. Pytania omówione w niniejszym artykule regularnie pojawiają się na rozmowach zarówno w polskich firmach technologicznych, jak i w globalnych korporacjach prowadzących rekrutację zdalną.

Kluczowy wniosek dla kandydatów: rekruterzy doce niają nie tylko znajomość teorii, ale przede wszystkim rozumienie typowych pułapek — wycieku danych, my lących metryk przy niezbalansowanych klasach, training-serving skew czy błędnej walidacji na szeregach czasowych. Najlepszym przygotowaniem jest regularna praktyka z implementacjami od podstaw, analiza przypadków, w których modele zawodzą, oraz budowanie portfolio projektów demonstrujących zrozumienie pełnego cyklu życia modelu w produkcji.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/pl/blog/data-science/top-25-data-science-interview-questions-2026