...
Pregătire interviuri

100 de întrebări de interviu pentru Data Scientist / ML Engineer, cu răspunsuri

Întrebările care apar des la interviurile de Data Scientist / ML Engineer, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 52junior
  • 34mid
  • 14senior
  • 145 minde citit
Întrebări de interviu Data Scientist / ML Engineer cu răspunsuri

Un proces de interviu pentru Data Scientist sau ML Engineer începe de obicei cu o discuție cu cineva din HR sau cu un recruiter, unde se verifică motivația, așteptările și dacă profilul tău se potrivește cu rolul. Urmează unul sau mai multe interviuri tehnice: întrebări de statistică și machine learning, SQL scris pe loc, Python cu pandas și NumPy și, des, o problemă de algoritmi la nivel de bază. Multe echipe dau și o temă pentru acasă (un set de date, o întrebare de business, un notebook de predat) sau un studiu de caz discutat live, în care contează mai mult raționamentul decât scorul final. La final apare de obicei o discuție cu managerul sau cu echipa, cu întrebări comportamentale.

La nivel junior se urmărește dacă înțelegi fundamentele: de ce împarți datele în train și test, ce înseamnă overfitting, cum citești o matrice de confuzie, cum scrii un JOIN sau un GROUP BY corect și dacă poți explica simplu ce ai făcut într-un proiect. La nivel mid se așteaptă să alegi singur metrici și validări potrivite, să eviți data leakage, să proiectezi un A/B test și să duci un model până la un API sau un job programat. La senior întrebările se mută spre decizii: când nu merită ML, cum monitorizezi un model în producție, cum explici compromisurile unor oameni care nu sunt tehnici.

Folosește pagina așa: citește întâi răspunsul scurt și încearcă să răspunzi cu voce tare înainte să deschizi explicația detaliată. Rulează exemplele de cod în Python sau în baza ta de date, schimbă-le și vezi ce se întâmplă. Notează întrebările la care te-ai blocat și revino la ele după câteva zile. Secțiunea de la final, cu întrebări comportamentale, merită pregătită cu exemple din proiectele tale, nu învățată pe de rost.

Python, NumPy și pandas

1 Junior

Care este diferența dintre list, tuple, set și dict în Python și când folosești fiecare structură?

Răspuns scurt: list este o secvență ordonată și modificabilă, tuple una ordonată și imutabilă, set o colecție de elemente unice fără ordine, iar dict asociază chei unice cu valori. Alegi după operația pe care o faci cel mai des.

Lista păstrează ordinea, acceptă duplicate și se poate modifica: o folosești pentru o serie de valori pe care o parcurgi sau o extinzi. Tuplul e tot ordonat, dar imutabil, deci poate fi cheie de dicționar sau element într-un set; e potrivit pentru înregistrări fixe, de exemplu (lat, lon).

set reține doar valori unice și verifică apartenența în timp mediu O(1), pentru că folosește o tabelă hash. dict face același lucru pentru chei și le asociază o valoare; din Python 3.7 păstrează ordinea inserării.

PYTHON
ids = [3, 1, 3, 2]
unice = set(ids)            # {1, 2, 3}
print(2 in unice)           # True, căutare rapidă
coord = (44.43, 26.10)      # tuplu, poate fi cheie
orase = {coord: "București"}
contor = {}
for x in ids:
    contor[x] = contor.get(x, 0) + 1
print(contor)               # {3: 2, 1: 1, 2: 1}

Diferența contează în data science când verifici repetat dacă un element există: x in lista parcurge toată lista (O(n)), pe când x in set e aproape constant. Pe un milion de verificări, alegerea greșită transformă un script de secunde într-unul de minute.

Ce urmărește intervievatorul: Verifică dacă știi structurile de bază și costul operațiilor pe ele. Greșeala tipică: căutări repetate în liste mari în loc de set sau dict.

2 Junior

Ce afișează codul de mai jos și de ce? def adauga(x, lista=[]): lista.append(x); return lista, apelat de două ori.

Răspuns scurt: Al doilea apel afișează [1, 2], nu [2], pentru că valoarea implicită [] se creează o singură dată, la definirea funcției, și e reutilizată între apeluri.

PYTHON
def adauga(x, lista=[]):
    lista.append(x)
    return lista

print(adauga(1))   # [1]
print(adauga(2))   # [1, 2]

În Python, valorile implicite ale parametrilor se evaluează o singură dată, când rulează instrucțiunea def. Lista goală devine un obiect atașat funcției, iar fiecare apel care nu primește lista modifică același obiect. Pentru că lista este mutabilă, modificările se acumulează.

Soluția idiomatică este None ca valoare implicită și crearea listei în corpul funcției:

PYTHON
def adauga(x, lista=None):
    if lista is None:
        lista = []
    lista.append(x)
    return lista

Aceeași capcană apare cu dicționare sau seturi implicite, de exemplu un cache config={} pe care îl modifici fără să vrei. Cu tipuri imutabile (int, str, tuple) problema nu există, pentru că orice „modificare” creează un obiect nou. Întrebarea testează de fapt dacă înțelegi diferența dintre un nume și obiectul la care se referă, lucru important și când treci DataFrame-uri între funcții.

Ce urmărește intervievatorul: Testează înțelegerea modelului de obiecte din Python. Mulți candidați răspund [2] și nu pot explica momentul evaluării valorii implicite.

3 Junior

Ce este un list comprehension și prin ce diferă de o expresie generator?

Răspuns scurt: Un list comprehension construiește imediat toată lista în memorie, pe când o expresie generator produce elementele pe rând, doar când sunt cerute, ceea ce economisește memorie pe volume mari.

Un list comprehension este o sintaxă compactă pentru a construi o listă dintr-un iterabil, cu transformare și filtrare opțională:

PYTHON
patrate = [x * x for x in range(10) if x % 2 == 0]
print(patrate)            # [0, 4, 16, 36, 64]

Dacă înlocuiești parantezele drepte cu paranteze rotunde, obții o expresie generator. Ea nu calculează nimic la creare; returnează un obiect care produce valoarea următoare de fiecare dată când e iterat:

PYTHON
gen = (x * x for x in range(10_000_000))
print(sum(gen))           # memorie constantă

Lista cu zece milioane de pătrate ar ocupa sute de megaocteți, pe când generatorul ține în memorie doar starea curentă. Dezavantajul: un generator se poate parcurge o singură dată și nu are len() sau acces prin index.

În practică folosești list comprehension când ai nevoie de rezultat de mai multe ori sau când e mic, și generator când doar agregi (sum, max, any) sau citești un fișier mare linie cu linie. Există și variantele pentru dicționar și set: {k: v for k, v in perechi} și {x for x in valori}. Atenție însă: pentru coloane numerice dintr-un DataFrame, ambele sunt mai lente decât operațiile vectorizate din pandas sau NumPy.

Ce urmărește intervievatorul: Verifică stilul idiomatic și conștiința costului de memorie. Greșeala tipică e să crezi că generatorul poate fi reutilizat.

4 Junior

Care este diferența dintre o copie superficială și o copie profundă în Python? Dar în pandas?

Răspuns scurt: O copie superficială (copy.copy) creează un container nou care referă aceleași obiecte interioare; o copie profundă (copy.deepcopy) copiază recursiv tot. În pandas, df.copy() face implicit copie profundă a datelor.

Atribuirea b = a nu copiază nimic: ambele nume referă același obiect. O copie superficială creează un obiect exterior nou, dar elementele lui sunt aceleași obiecte ca în original:

PYTHON
import copy
a = [[1, 2], [3, 4]]
b = copy.copy(a)
b[0].append(99)
print(a)          # [[1, 2, 99], [3, 4]]
c = copy.deepcopy(a)
c[0].append(7)
print(a)          # neschimbat: [[1, 2, 99], [3, 4]]

Modificarea listei interioare prin b se vede și în a, pentru că lista interioară e comună. deepcopy copiază recursiv, așa că c e complet independent.

În pandas, df.copy() are deep=True implicit și copiază datele și indexul. Cu deep=False obții un obiect nou care împarte datele cu originalul. Capcana practică e alta: când iei o felie, de exemplu sub = df[df.varsta > 30], și apoi o modifici, pandas poate afișa SettingWithCopyWarning, pentru că nu e clar dacă scrii în original sau într-o copie. Din pandas 2.x există modul Copy-on-Write (activabil cu pd.options.mode.copy_on_write = True, implicit în pandas 3.0), care face comportamentul previzibil: orice obiect derivat se comportă ca o copie. Regula sigură rămâne: dacă vrei să modifici un subset, apelează explicit .copy().

Ce urmărește intervievatorul: Verifică dacă înțelegi referințele și de ce apar modificări neașteptate în date. Mulți confundă atribuirea cu copierea.

5 Junior

De ce operațiile vectorizate din NumPy sunt mult mai rapide decât o buclă for în Python?

Răspuns scurt: Pentru că bucla rulează în C, pe un bloc continuu de memorie cu un singur tip de date, fără costul interpretorului Python și al obiectelor individuale pentru fiecare element.

Un ndarray NumPy stochează valorile într-un bloc continuu de memorie, toate de același tip (de exemplu float64). Când scrii a * 2, NumPy apelează o funcție compilată în C care parcurge blocul direct, poate folosi instrucțiuni SIMD ale procesorului și nu creează obiecte Python intermediare.

O buclă Python, în schimb, pentru fiecare element: citește un obiect float separat din memorie, verifică tipul, apelează operatorul prin interpretor și creează un obiect nou pentru rezultat. Costul acesta fix pe element domină pe vectori mari.

PYTHON
import numpy as np, time
x = np.random.rand(5_000_000)

t = time.perf_counter()
s1 = sum(v * v for v in x)
print("bucla:", time.perf_counter() - t)

t = time.perf_counter()
s2 = np.dot(x, x)
print("numpy:", time.perf_counter() - t)

Pe orice calculator diferența e de ordinul zecilor sau sutelor de ori; cifra exactă depinde de mașină, așa că măsoar-o tu. Același principiu explică de ce în pandas preferi df["a"] * df["b"] în locul lui df.apply(..., axis=1), care cheamă o funcție Python pentru fiecare rând. Când logica nu se poate vectoriza ușor, alternativele sunt np.where, np.select, operații pe grupuri sau compilarea cu Numba.

Ce urmărește intervievatorul: Verifică dacă știi de ce contează vectorizarea, nu doar că există. Greșeala tipică: apply pe rânduri peste tot.

6 Junior

Cum ai sorta o listă de dicționare după o cheie și ce rol au funcțiile lambda în asta?

Răspuns scurt: Folosești sorted(lista, key=lambda d: d['cheie']). key primește o funcție aplicată fiecărui element, iar lambda e o funcție anonimă scurtă, scrisă direct pe loc.

sorted() returnează o listă nouă sortată, iar list.sort() sortează pe loc și returnează None. Ambele acceptă parametrul key, o funcție care primește un element și întoarce valoarea după care se compară.

PYTHON
clienti = [
    {"nume": "Ana", "oras": "Cluj", "valoare": 320},
    {"nume": "Dan", "oras": "Iași", "valoare": 150},
    {"nume": "Ioana", "oras": "Cluj", "valoare": 500},
]
dupa_valoare = sorted(clienti, key=lambda c: c["valoare"], reverse=True)
print([c["nume"] for c in dupa_valoare])   # ['Ioana', 'Ana', 'Dan']

# sortare după două criterii: oraș crescător, valoare descrescător
dupa_doua = sorted(clienti, key=lambda c: (c["oras"], -c["valoare"]))
print([c["nume"] for c in dupa_doua])      # ['Ioana', 'Ana', 'Dan']

lambda c: c["valoare"] este echivalent cu o funcție def de o linie. E util pentru expresii scurte; pentru logică mai complexă, o funcție cu nume e mai lizibilă. Alternativa din biblioteca standard este operator.itemgetter("valoare"), puțin mai rapidă.

Sortarea din Python (Timsort) este stabilă: elementele egale își păstrează ordinea relativă, deci poți sorta în mai mulți pași. Complexitatea este O(n log n). În pandas, echivalentul este df.sort_values(["oras", "valoare"], ascending=[True, False]).

Ce urmărește intervievatorul: Verifică fluența în Python de zi cu zi. Candidații uită des că list.sort() întoarce None.

7 Mid

Ce este broadcasting-ul în NumPy? Dă un exemplu în care ajută și unul în care produce o eroare.

Răspuns scurt: Broadcasting-ul este regula prin care NumPy aplică operații între array-uri cu forme diferite, „întinzând” virtual dimensiunile de mărime 1 fără să copieze datele. Formele trebuie să fie compatibile pornind de la ultima dimensiune.

NumPy compară formele de la dreapta la stânga. Două dimensiuni sunt compatibile dacă sunt egale sau dacă una dintre ele este 1. Dimensiunea 1 se repetă virtual cât e nevoie, fără alocare de memorie.

Exemplu util: standardizarea coloanelor unei matrice de date.

PYTHON
import numpy as np
X = np.random.rand(1000, 3)        # (1000, 3)
medii = X.mean(axis=0)             # (3,)
std = X.std(axis=0)                # (3,)
Z = (X - medii) / std              # (1000, 3) - (3,) funcționează
print(Z.mean(axis=0).round(6))     # aproape 0 pe fiecare coloană

Forma (3,) e tratată ca (1, 3) și repetată pe cele 1000 de rânduri.

Exemplu de eroare: vrei să scazi media fiecărui rând.

PYTHON
medii_rand = X.mean(axis=1)        # (1000,)
# X - medii_rand  -> ValueError: operands could not be broadcast
Z2 = X - medii_rand[:, None]       # (1000, 1) se potrivește cu (1000, 3)

(1000, 3) și (1000,) comparate de la dreapta dau 3 și 1000, incompatibile. Adăugarea unei axe cu [:, None] (sau keepdims=True la mean) rezolvă problema. Pericolul real nu e eroarea, ci broadcasting-ul care reușește din greșeală: (n,) minus (n, 1) produce o matrice (n, n) și un rezultat greșit, fără niciun mesaj.

Ce urmărește intervievatorul: Verifică dacă poți lucra cu forme de array-uri fără bucle. Greșeala tipică: un (n,1) combinat cu (n,) care creează tăcut o matrice uriașă.

8 Mid

Ce este un decorator în Python? Scrie unul care măsoară timpul de execuție al unei funcții.

Răspuns scurt: Un decorator este o funcție care primește o funcție și întoarce o altă funcție care o „învelește”, adăugând comportament (logare, timp, cache) fără să modifici codul original. Sintaxa @nume e doar prescurtare pentru f = nume(f).

În Python funcțiile sunt obiecte: pot fi transmise ca argumente și returnate. Un decorator profită de asta.

PYTHON
import functools, time

def cronometru(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        rezultat = func(*args, **kwargs)
        durata = time.perf_counter() - start
        print(f"{func.__name__} a durat {durata:.3f} s")
        return rezultat
    return wrapper

@cronometru
def antreneaza(n):
    return sum(i * i for i in range(n))

antreneaza(1_000_000)

*args, **kwargs permit decorarea oricărei funcții, indiferent de parametri. functools.wraps copiază numele și docstring-ul funcției originale în wrapper; fără el, antreneaza.__name__ ar fi "wrapper", ceea ce încurcă logurile și unele unelte.

În ecosistemul de date întâlnești decoratori peste tot: @functools.lru_cache pentru memoizare, @app.get("/predict") în FastAPI, @pytest.fixture în teste, @task în Airflow sau Prefect, @njit în Numba. Un decorator cu parametri (de exemplu @retry(n=3)) are un nivel în plus: o funcție care primește parametrii și întoarce decoratorul propriu-zis.

Ce urmărește intervievatorul: Verifică înțelegerea funcțiilor ca obiecte și a closure-urilor. Mulți uită functools.wraps sau nu returnează rezultatul funcției originale.

9 Mid

Ce este GIL și când folosești threading, multiprocessing sau asyncio într-un proiect de date?

Răspuns scurt: GIL (Global Interpreter Lock) permite unui singur thread să execute bytecode Python la un moment dat în CPython. Pentru calcule CPU folosești procese, pentru așteptări I/O threading sau asyncio.

În CPython, GIL este un lacăt care protejează starea internă a interpretorului. Consecința: două thread-uri care fac calcule pure în Python nu rulează cu adevărat în paralel pe două nuclee. Thread-urile tot ajută când codul așteaptă (rețea, disc, baze de date), pentru că GIL se eliberează în timpul așteptării.

Reguli practice:

  • I/O-bound (descărcat sute de fișiere, apelat un API): concurrent.futures.ThreadPoolExecutor sau asyncio cu un client asincron.
  • CPU-bound în Python pur (parsare, feature-uri calculate rând cu rând): ProcessPoolExecutor sau multiprocessing, fiecare proces având propriul interpretor și propriul GIL. Costul: datele se serializează între procese.
  • Codul NumPy, pandas sau scikit-learn eliberează de multe ori GIL în porțiunile scrise în C, iar multe estimatoare au deja n_jobs=-1, care paralelizează intern.
PYTHON
from concurrent.futures import ProcessPoolExecutor

def scor(seed):
    import random
    random.seed(seed)
    return sum(random.random() for _ in range(2_000_000))

if __name__ == "__main__":
    with ProcessPoolExecutor() as ex:
        print(list(ex.map(scor, range(4))))

if __name__ == "__main__" e obligatoriu pe Windows și macOS, unde procesele noi reimportă modulul. Merită menționat că Python 3.13 a introdus o variantă experimentală fără GIL (free-threaded), încă neadoptată pe scară largă în bibliotecile de date.

Ce urmărește intervievatorul: Verifică dacă știi să alegi modelul de concurență potrivit. Greșeala tipică: thread-uri pentru calcule CPU și așteptarea unei accelerări.

10 Senior

Cum ai procesa în Python un fișier CSV de 50 GB pe un laptop cu 16 GB RAM?

Răspuns scurt: Nu îl încarci întreg: îl citești pe bucăți (chunksize), reduci tipurile și coloanele, agregi incremental sau folosești unelte făcute pentru date mai mari decât memoria, ca DuckDB, Polars în mod lazy ori conversia în Parquet.

Primul pas este să afli ce trebuie de fapt calculat. De multe ori ai nevoie de câteva coloane și de agregări, nu de toate rândurile în memorie.

Variante, de la simplu la robust:

  • Citire pe bucăți cu pandas și agregare incrementală:
PYTHON
import pandas as pd
total = {}
for bucata in pd.read_csv("vanzari.csv", usecols=["magazin", "suma"],
                          dtype={"magazin": "category", "suma": "float32"},
                          chunksize=1_000_000):
    s = bucata.groupby("magazin", observed=True)["suma"].sum()
    for k, v in s.items():
        total[k] = total.get(k, 0) + v
  • Tipuri mai mici: category pentru text repetitiv, float32/int32 unde precizia permite; reducerea poate fi de câteva ori.
  • DuckDB rulează SQL direct pe CSV sau Parquet, în flux și pe mai multe nuclee: duckdb.sql("SELECT magazin, SUM(suma) FROM 'vanzari.csv' GROUP BY 1").df().
  • Polars cu scan_csv(...).group_by(...).agg(...).collect() construiește un plan lazy și procesează în streaming.
  • Conversie o singură dată în Parquet, format pe coloane comprimat, după care citirile ulterioare sunt mult mai rapide și pot selecta doar coloanele necesare.

Dacă datele cresc constant sau trebuie procesate zilnic, mutarea calculului într-un warehouse sau în Spark devine justificată. La interviu contează să arăți că pui întâi întrebarea „ce rezultat îmi trebuie?” și abia apoi alegi unealta.

Ce urmărește intervievatorul: Verifică experiența practică cu date reale, mari. Răspunsul slab este „cumpăr mai multă memorie” sau „folosesc Spark” fără justificare.

SQL pentru date

11 Junior

Care este diferența dintre WHERE și HAVING în SQL?

Răspuns scurt: WHERE filtrează rândurile înainte de grupare, deci nu poate folosi agregări; HAVING filtrează grupurile după GROUP BY și poate folosi funcții ca COUNT sau SUM.

Interogarea se evaluează logic în etape: întâi se iau rândurile din tabele, WHERE elimină rândurile care nu respectă condiția, apoi GROUP BY formează grupurile, se calculează agregările, iar HAVING elimină grupurile nedorite.

SQL
SELECT client_id, COUNT(*) AS nr_comenzi, SUM(valoare) AS total
FROM comenzi
WHERE status = 'livrata'          -- filtru pe rânduri
GROUP BY client_id
HAVING COUNT(*) >= 3;             -- filtru pe grupuri

Aici numărăm doar comenzile livrate și păstrăm clienții cu cel puțin trei astfel de comenzi. Dacă ai pune COUNT(*) >= 3 în WHERE, baza de date ar da eroare, pentru că la acel moment grupurile nu există încă.

Invers, poți tehnic să scrii HAVING status = 'livrata' doar dacă status e în GROUP BY, dar e mai lent și mai greu de citit: filtrarea timpurie cu WHERE reduce volumul de date înainte de grupare și permite folosirea indexurilor.

Regula simplă: condițiile pe coloane individuale merg în WHERE, condițiile pe rezultate agregate merg în HAVING. În analize, confuzia dintre ele duce la cifre greșite, de exemplu numărând și comenzile anulate în pragul de „client fidel”.

Ce urmărește intervievatorul: Întrebare de bază pentru orice rol cu date. Arată dacă înțelegi ordinea în care se evaluează o interogare.

12 Junior

Explică tipurile de JOIN: INNER, LEFT, RIGHT, FULL OUTER. Ce se întâmplă cu rândurile fără corespondent?

Răspuns scurt: INNER JOIN păstrează doar perechile care se potrivesc; LEFT JOIN păstrează toate rândurile din stânga, cu NULL unde lipsește corespondentul; RIGHT invers; FULL OUTER păstrează tot din ambele părți.

Să presupunem tabelele clienti(id, nume) și comenzi(id, client_id, valoare).

SQL
-- doar clienții care au comenzi
SELECT c.nume, o.valoare
FROM clienti c
INNER JOIN comenzi o ON o.client_id = c.id;

-- toți clienții, inclusiv cei fără comenzi (valoare NULL)
SELECT c.nume, COALESCE(SUM(o.valoare), 0) AS total
FROM clienti c
LEFT JOIN comenzi o ON o.client_id = c.id
GROUP BY c.nume;

RIGHT JOIN este simetric cu LEFT JOIN și se poate rescrie mereu inversând tabelele, de aceea e rar folosit. FULL OUTER JOIN e util la reconcilieri, când vrei să vezi ce există într-o sursă și lipsește din cealaltă. Mai există CROSS JOIN, produsul cartezian, folosit de exemplu pentru a genera toate combinațiile zi x produs.

Două capcane frecvente la interviu:

  • Multiplicarea rândurilor: dacă cheia nu e unică în ambele tabele, un client cu 3 comenzi și 2 adrese produce 6 rânduri, iar sumele se umflă.
  • Un filtru în WHERE pe tabelul din dreapta transformă LEFT JOIN într-un INNER JOIN: WHERE o.status = 'livrata' elimină clienții fără comenzi, pentru că NULL nu trece condiția. Dacă vrei să-i păstrezi, mută condiția în ON.

Ce urmărește intervievatorul: Verifică dacă știi ce rânduri apar în rezultat. Cele două capcane de mai sus sunt sursa clasică de cifre greșite în rapoarte.

13 Junior

Ce diferență este între COUNT(*), COUNT(coloana) și COUNT(DISTINCT coloana)?

Răspuns scurt: COUNT(*) numără toate rândurile, COUNT(coloana) numără rândurile unde coloana nu e NULL, iar COUNT(DISTINCT coloana) numără valorile distincte non-NULL.

Diferența apare imediat ce datele au valori lipsă sau repetate. Pentru un tabel vizite(user_id, pagina):

SQL
SELECT
  COUNT(*)                 AS nr_vizite,
  COUNT(user_id)           AS vizite_cu_user,
  COUNT(DISTINCT user_id)  AS utilizatori_unici
FROM vizite;

Dacă 100 de vizite au 20 fără user_id (vizitatori anonimi) și 30 de utilizatori distincți, rezultatul este 100, 80 și 30.

Același principiu se aplică altor agregări: SUM, AVG, MIN, MAX ignoră NULL-urile. Asta înseamnă că AVG(nota) e media doar pe rândurile cu notă, nu pe toate. Dacă vrei să tratezi lipsa ca 0, scrii explicit AVG(COALESCE(nota, 0)), iar decizia trebuie justificată de business, nu luată automat.

O întrebare înrudită care apare des: „câți utilizatori au făcut cel puțin o achiziție, ca procent din total?”

SQL
SELECT
  COUNT(DISTINCT CASE WHEN tip = 'achizitie' THEN user_id END) * 1.0
  / COUNT(DISTINCT user_id) AS rata_conversie
FROM evenimente;

CASE fără ELSE produce NULL, iar COUNT îl ignoră. Înmulțirea cu 1.0 evită împărțirea întreagă din unele baze de date, de exemplu PostgreSQL.

Ce urmărește intervievatorul: Verifică atenția la NULL și la duplicate, două surse majore de erori în metrici. Mulți folosesc COUNT(*) când întrebarea cere utilizatori unici.

14 Junior

Cum se comportă NULL în SQL la comparații, în WHERE și în funcții de agregare?

Răspuns scurt: NULL înseamnă „valoare necunoscută”: orice comparație cu el dă UNKNOWN, nu TRUE, deci WHERE col = NULL nu întoarce nimic. Verifici cu IS NULL, înlocuiești cu COALESCE, iar agregările îl ignoră.

SQL folosește logică cu trei valori: TRUE, FALSE și UNKNOWN. NULL = NULL nu este TRUE, ci UNKNOWN, iar WHERE păstrează doar rândurile unde condiția e TRUE.

SQL
SELECT * FROM clienti WHERE telefon = NULL;     -- 0 rânduri, mereu
SELECT * FROM clienti WHERE telefon IS NULL;    -- corect
SELECT nume, COALESCE(telefon, 'necunoscut') FROM clienti;

Capcane practice:

  • WHERE oras <> 'Cluj' nu returnează rândurile cu oras NULL. Dacă le vrei, adaugi OR oras IS NULL.
  • NOT IN cu o subinterogare care conține un NULL întoarce zero rânduri: id NOT IN (1, 2, NULL) nu poate fi niciodată TRUE. Folosește NOT EXISTS, care nu are această problemă.
  • SUM, AVG, COUNT(coloana) ignoră NULL. AVG pe o coloană cu multe lipsuri reflectă doar rândurile completate.
  • La GROUP BY, toate NULL-urile formează un singur grup.
  • În sortare, poziția NULL-urilor diferă între baze (PostgreSQL le pune la final la ASC); poți controla cu NULLS FIRST sau NULLS LAST acolo unde e suportat.

Pentru un data scientist, NULL nu e doar o problemă de sintaxă: el ascunde de obicei un proces de colectare. Înainte să-l înlocuiești, întreabă de ce lipsește valoarea.

Ce urmărește intervievatorul: Verifică dacă știi logica cu trei valori. Capcana cu NOT IN și NULL e clasică și deosebește un candidat atent.

15 Junior

În ce ordine se execută logic clauzele unui SELECT și de ce contează?

Răspuns scurt: Ordinea logică este FROM și JOIN, WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY, LIMIT. De aceea un alias definit în SELECT nu se poate folosi în WHERE, dar se poate folosi în ORDER BY.

Interogarea se scrie începând cu SELECT, dar se evaluează logic altfel:

  • FROM și JOIN: se construiește setul de rânduri;
  • WHERE: se filtrează rândurile;
  • GROUP BY: se formează grupurile;
  • HAVING: se filtrează grupurile;
  • SELECT: se calculează expresiile și aliasurile (inclusiv funcțiile fereastră);
  • DISTINCT: se elimină duplicatele;
  • ORDER BY: se sortează;
  • LIMIT / OFFSET: se taie rezultatul.

Consecințe practice:

SQL
-- eroare în majoritatea bazelor: alias-ul nu există încă în WHERE
SELECT pret * cantitate AS total FROM linii WHERE total > 100;

-- corect
SELECT pret * cantitate AS total FROM linii WHERE pret * cantitate > 100;

-- în ORDER BY alias-ul e vizibil
SELECT pret * cantitate AS total FROM linii ORDER BY total DESC;

Tot din această ordine rezultă că nu poți filtra direct pe o funcție fereastră în WHERE: ROW_NUMBER() se calculează la pasul SELECT. Soluția este o subinterogare sau un CTE, ori clauza QUALIFY în bazele care o au (Snowflake, BigQuery, DuckDB). Ordinea este una logică: optimizatorul poate executa fizic altfel, de exemplu împinge filtrele mai devreme, dar rezultatul trebuie să fie același.

Ce urmărește intervievatorul: Verifică înțelegerea profundă a SQL, nu doar memorarea sintaxei. Explică multe erori pe care candidații le întâlnesc la scrierea live.

16 Mid

Ce sunt funcțiile fereastră în SQL? Explică diferența dintre ROW_NUMBER, RANK și DENSE_RANK.

Răspuns scurt: Funcțiile fereastră calculează o valoare pentru fiecare rând pe baza unui grup de rânduri înrudite (OVER (PARTITION BY ... ORDER BY ...)), fără să comprime rândurile ca GROUP BY. Cele trei funcții diferă la egalități.

Spre deosebire de GROUP BY, care întoarce un rând pe grup, o funcție fereastră păstrează toate rândurile și adaugă o coloană calculată peste „fereastra” definită în OVER.

SQL
SELECT
  angajat, departament, salariu,
  ROW_NUMBER() OVER (PARTITION BY departament ORDER BY salariu DESC) AS rn,
  RANK()       OVER (PARTITION BY departament ORDER BY salariu DESC) AS rk,
  DENSE_RANK() OVER (PARTITION BY departament ORDER BY salariu DESC) AS drk,
  AVG(salariu) OVER (PARTITION BY departament) AS medie_dep
FROM angajati;

Pentru salariile 9000, 8000, 8000, 7000 din același departament:

  • ROW_NUMBER: 1, 2, 3, 4 (unic, egalitatea se rupe arbitrar);
  • RANK: 1, 2, 2, 4 (sare peste poziții după egalitate);
  • DENSE_RANK: 1, 2, 2, 3 (fără goluri).

Alte funcții frecvente în analiză: LAG și LEAD (valoarea de pe rândul anterior sau următor, utile pentru diferențe între zile), SUM(...) OVER (ORDER BY data) pentru total cumulat și ferestre glisante cu ROWS BETWEEN 6 PRECEDING AND CURRENT ROW pentru medii pe 7 zile.

Alegerea între cele trei funcții de rang depinde de cerință: „primul rând per client” cere ROW_NUMBER, „toți angajații pe locul 1, inclusiv la egalitate” cere RANK sau DENSE_RANK.

Ce urmărește intervievatorul: Funcțiile fereastră apar aproape la orice interviu SQL pentru date. Se verifică și dacă știi comportamentul la egalități.

17 Mid

Scrie o interogare care întoarce cele mai mari două comenzi ale fiecărui client.

Răspuns scurt: Numerotezi comenzile fiecărui client cu ROW_NUMBER() OVER (PARTITION BY client_id ORDER BY valoare DESC) într-un CTE, apoi păstrezi rândurile cu numărul cel mult 2.

Problema „top N pe grup” este una dintre cele mai frecvente la interviurile SQL. Soluția standard folosește o funcție fereastră și un filtru exterior, pentru că funcția nu poate fi folosită direct în WHERE.

SQL
WITH numerotate AS (
  SELECT
    client_id,
    comanda_id,
    valoare,
    ROW_NUMBER() OVER (
      PARTITION BY client_id
      ORDER BY valoare DESC, comanda_id
    ) AS rn
  FROM comenzi
)
SELECT client_id, comanda_id, valoare
FROM numerotate
WHERE rn <= 2
ORDER BY client_id, rn;

Detalii pe care merită să le spui cu voce tare:

  • Am adăugat comanda_id în ORDER BY ca să fac rezultatul determinist la valori egale.
  • Dacă cerința este „inclusiv egalitățile”, înlocuiesc cu DENSE_RANK(); atunci un client poate avea mai mult de două rânduri.
  • Clienții cu o singură comandă apar cu un singur rând, ceea ce de obicei e corect.

O variantă fără funcții fereastră, cu subinterogare corelată (WHERE (SELECT COUNT(*) FROM comenzi c2 WHERE c2.client_id = c.client_id AND c2.valoare > c.valoare) < 2), funcționează, dar e greu de citit și are complexitate pătratică pe client. Aceeași logică se scrie în pandas cu df.sort_values("valoare", ascending=False).groupby("client_id").head(2).

Ce urmărește intervievatorul: Problemă clasică de scris live. Se urmărește dacă alegi funcția de rang potrivită și dacă te gândești la egalități.

18 Mid

Ce este un CTE și cum ai calcula retenția utilizatorilor pe luni (analiză de cohortă) în SQL?

Răspuns scurt: Un CTE (WITH nume AS (...)) este o subinterogare cu nume care face SQL-ul lizibil și pe pași. Pentru retenție, atribui fiecărui utilizator luna primei activități, apoi numeri câți sunt activi în fiecare lună ulterioară.

Un CTE (Common Table Expression) îți permite să construiești interogarea în pași numiți, ca niște variabile temporare. Există și CTE-uri recursive, utile pentru ierarhii.

Pentru cohorte avem tabelul activitati(user_id, data). Exemplu în PostgreSQL:

SQL
WITH prima AS (
  SELECT user_id, DATE_TRUNC('month', MIN(data)) AS cohorta
  FROM activitati
  GROUP BY user_id
),
lunar AS (
  SELECT DISTINCT user_id, DATE_TRUNC('month', data) AS luna
  FROM activitati
),
combinat AS (
  SELECT p.cohorta,
         (EXTRACT(YEAR FROM l.luna) - EXTRACT(YEAR FROM p.cohorta)) * 12
         + EXTRACT(MONTH FROM l.luna) - EXTRACT(MONTH FROM p.cohorta) AS luna_nr,
         l.user_id
  FROM prima p JOIN lunar l ON l.user_id = p.user_id
)
SELECT cohorta, luna_nr,
       COUNT(DISTINCT user_id) AS activi,
       ROUND(100.0 * COUNT(DISTINCT user_id)
             / FIRST_VALUE(COUNT(DISTINCT user_id))
               OVER (PARTITION BY cohorta ORDER BY luna_nr), 1) AS procent
FROM combinat
GROUP BY cohorta, luna_nr
ORDER BY cohorta, luna_nr;

Luna 0 are mereu 100%, iar valorile următoare arată ce parte din cohortă revine. Funcțiile de dată diferă între baze (DATE_TRUNC în PostgreSQL și Snowflake, DATE_FORMAT în MySQL), așa că spune ce dialect folosești. La interviu, explică întâi definiția: ce înseamnă „activ”, iar luna se calculează calendaristic sau la 30 de zile?

Ce urmărește intervievatorul: Verifică dacă poți structura o analiză reală de produs în SQL. Contează la fel de mult clarificarea definițiilor cât și sintaxa.

19 Senior

O interogare de raportare a început să ruleze în 10 minute în loc de câteva secunde. Cum o investighezi și o optimizezi?

Răspuns scurt: Pornești de la planul de execuție (EXPLAIN ANALYZE), cauți scanări complete, join-uri care multiplică rânduri și estimări greșite, apoi aplici indexuri, filtrare mai devreme, statistici actualizate sau pre-agregări. Măsori după fiecare schimbare.

Un răspuns structurat:

  • Ce s-a schimbat? Volum de date crescut, o modificare de cod, un index șters, statistici învechite după un import mare. Compari cu ultima versiune care mergea bine.
  • Planul de execuție. În PostgreSQL, EXPLAIN (ANALYZE, BUFFERS) arată pașii reali, timpul și numărul de rânduri. Cauți Seq Scan pe tabele mari unde te așteptai la index, Nested Loop peste milioane de rânduri și diferențe mari între rândurile estimate și cele reale, semn de statistici vechi (ANALYZE tabel).
  • Join-uri care explodează. O cheie neunică produce mai multe rânduri decât te aștepți; un COUNT(*) pe pașii intermediari confirmă.
  • Predicate care împiedică indexul. WHERE DATE(creat_la) = '2026-10-01' aplică o funcție pe coloană; rescrie ca interval creat_la >= '2026-10-01' AND creat_la < '2026-10-02'.
  • Indexuri potrivite. Index compus pe coloanele din filtru și join, în ordinea selectivității și a utilizării, eventual cu coloanele din SELECT incluse ca să evite citirea tabelului.
  • Mai puține date. Selectezi doar coloanele necesare, filtrezi înainte de join, iar pe warehouse-uri ca BigQuery sau Snowflake te bazezi pe partiționare și clustering.
  • Pre-agregare. Pentru rapoarte repetitive, un tabel sau o vedere materializată actualizată periodic.

Fiecare ipoteză se validează cu o măsurătoare, nu prin ghicit. Un index ajută citirea, dar încetinește scrierile și ocupă spațiu, deci trebuie justificat.

Ce urmărește intervievatorul: Verifică experiența cu sisteme reale și metoda de depanare. Răspunsul slab sare direct la „adaug un index” fără să se uite la plan.

Statistică și probabilități

20 Junior

Care este diferența dintre medie, mediană și mod? Când preferi mediana?

Răspuns scurt: Media este suma împărțită la număr, mediana este valoarea din mijloc după sortare, modul este valoarea cea mai frecventă. Preferi mediana la distribuții asimetrice sau cu valori extreme, de exemplu venituri sau timpi de răspuns.

Toate trei descriu „centrul” datelor, dar reacționează diferit la valorile extreme.

PYTHON
import numpy as np
from statistics import mode
venituri = np.array([3000, 3200, 3500, 3600, 4000, 50000])
print(venituri.mean())       # 11216.67
print(np.median(venituri))   # 3550.0
print(mode([1, 2, 2, 3]))    # 2

O singură valoare extremă ridică media de peste trei ori, pe când mediana rămâne reprezentativă pentru majoritatea. Spunem că mediana este robustă la outlieri.

Când folosești fiecare:

  • Media: distribuții aproximativ simetrice, sau când îți trebuie totalul (media înmulțită cu numărul dă suma, util pentru venit total sau buget).
  • Mediana: distribuții asimetrice (venituri, prețuri de locuințe, durata sesiunilor, latențe). Pentru latențe se raportează des și percentile ca p95 sau p99.
  • Modul: date categoriale (cel mai vândut produs) sau discrete.

Relația dintre ele spune ceva despre formă: la o distribuție cu coadă lungă la dreapta, media este de obicei mai mare decât mediana. Într-un interviu e bine să spui că nu alegi un singur indicator orbește: te uiți la histogramă, raportezi mediana și câteva percentile și explici diferența față de medie.

Ce urmărește intervievatorul: Verifică intuiția statistică de bază. Candidații slabi raportează media la date asimetrice fără să observe distorsiunea.

21 Junior

Ce sunt varianța și deviația standard și de ce împărțim uneori la n-1 în loc de n?

Răspuns scurt: Varianța este media pătratelor abaterilor față de medie, iar deviația standard este rădăcina ei, în aceeași unitate ca datele. Împărțim la n-1 când estimăm varianța populației dintr-un eșantion, ca estimatorul să nu fie deplasat (corecția Bessel).

Varianța măsoară cât de împrăștiate sunt valorile în jurul mediei: pentru fiecare valoare calculezi abaterea față de medie, o ridici la pătrat (ca abaterile pozitive și negative să nu se anuleze) și faci media. Deviația standard este rădăcina pătrată a varianței și are avantajul că se exprimă în aceeași unitate ca datele (lei, secunde), deci se interpretează mai ușor.

Când ai doar un eșantion, media eșantionului este calculată din aceleași date, așa că valorile sunt în medie mai apropiate de ea decât de media adevărată a populației. Împărțirea la n ar subestima sistematic varianța. Împărțirea la n-1 (gradele de libertate) corectează această deplasare.

PYTHON
import numpy as np
x = np.array([2, 4, 4, 4, 5, 5, 7, 9])
print(np.var(x))            # 4.0   (ddof=0, împarte la n)
print(np.var(x, ddof=1))    # 4.571 (împarte la n-1)

import pandas as pd
print(pd.Series(x).var())   # 4.571, pandas folosește ddof=1 implicit

Atenție la această diferență de convenție: NumPy are ddof=0 implicit, pandas ddof=1. Pe eșantioane mari diferența devine neglijabilă, pe eșantioane mici contează. Deviația standard este sensibilă la outlieri, ca și media; alternativa robustă este IQR (distanța dintre percentilele 25 și 75) sau MAD (deviația absolută mediană).

Ce urmărește intervievatorul: Verifică înțelegerea, nu doar formula. Mulți nu știu de ce n-1 și nici că NumPy și pandas au implicit convenții diferite.

22 Junior

Ce este distribuția normală și ce spune regula 68-95-99,7?

Răspuns scurt: Distribuția normală este distribuția simetrică în formă de clopot, definită de medie și deviație standard. Aproximativ 68% din valori sunt la o deviație standard de medie, 95% la două și 99,7% la trei.

Distribuția normală (gaussiană) are densitatea simetrică în jurul mediei µ, iar lățimea ei e dată de deviația standard σ. Media, mediana și modul coincid.

Regula empirică 68-95-99,7 spune că, pentru date normale, aproximativ 68% din valori sunt în intervalul µ ± σ, 95% în µ ± 2σ (mai exact 1,96σ) și 99,7% în µ ± 3σ. De aici vin regulile simple de detecție a valorilor neobișnuite, de exemplu „mai mult de 3 deviații standard de medie”.

PYTHON
from scipy import stats
print(stats.norm.cdf(1) - stats.norm.cdf(-1))   # 0.6827
print(stats.norm.cdf(2) - stats.norm.cdf(-2))   # 0.9545
print(stats.norm.ppf(0.975))                    # 1.96

De ce contează atât de mult:

  • Prin teorema limită centrală, mediile eșantioanelor sunt aproximativ normale, ceea ce stă la baza intervalelor de încredere și a testelor z și t.
  • Multe metode presupun reziduuri normale (de exemplu inferența în regresia liniară).
  • Scorul z, (x - µ) / σ, arată la câte deviații standard se află o valoare.

Avertismentul important: multe date reale nu sunt normale. Veniturile, prețurile sau numărul de click-uri au cozi lungi. Verifici cu histogramă sau grafic Q-Q și, la nevoie, transformi datele (de exemplu cu logaritm) sau folosești metode care nu presupun normalitatea.

Ce urmărește intervievatorul: Verifică fundamentele. Greșeala tipică este să presupui că orice variabilă e normală și să aplici pragul de 3σ pe date cu coadă lungă.

23 Junior

Ce spune teorema limită centrală și de ce este importantă în practică?

Răspuns scurt: Teorema limită centrală spune că media unui eșantion suficient de mare de observații independente are o distribuție aproximativ normală, indiferent de distribuția datelor inițiale, cu condiția ca varianța să fie finită.

Ia orice populație cu medie µ și deviație standard σ finită, chiar foarte asimetrică. Extragi eșantioane de mărime n și calculezi media fiecăruia. Pe măsură ce n crește, distribuția acestor medii se apropie de o normală cu media µ și deviația standard σ / √n, numită eroare standard.

PYTHON
import numpy as np
rng = np.random.default_rng(0)
populatie = rng.exponential(scale=10, size=1_000_000)  # foarte asimetrică
medii = [rng.choice(populatie, 50).mean() for _ in range(5000)]
print(np.mean(medii), np.std(medii))   # aproape 10 și 10 / sqrt(50) = 1.41

O histogramă a lui medii arată aproape un clopot, deși populația are o coadă lungă.

De ce contează:

  • Justifică intervalele de încredere și testele z și t pentru medii, chiar dacă datele brute nu sunt normale. Asta e baza analizei unui A/B test pe medii sau proporții.
  • Arată că precizia crește cu rădăcina lui n: ca să înjumătățești eroarea standard, ai nevoie de un eșantion de patru ori mai mare.

Limitele: „suficient de mare” depinde de cât de asimetrice sunt datele; pentru distribuții cu cozi foarte grele (venituri, valoarea comenzilor cu câțiva clienți uriași) convergența e lentă. Observațiile trebuie să fie independente, iar pentru distribuții fără varianță finită teorema nu se aplică.

Ce urmărește intervievatorul: Verifică dacă înțelegi fundamentul inferenței statistice. Mulți spun greșit că „datele devin normale”, nu media lor.

24 Junior

Un test pentru o boală rară are sensibilitate 99% și specificitate 95%. Boala apare la 1% din populație. Care e probabilitatea ca o persoană cu test pozitiv să fie bolnavă?

Răspuns scurt: Aproximativ 17%. Cu teorema lui Bayes: 0,99 x 0,01 / (0,99 x 0,01 + 0,05 x 0,99) ≈ 0,167. Pentru că boala e rară, majoritatea rezultatelor pozitive vin din fals pozitivi.

Este un exemplu clasic de teorema lui Bayes: P(A|B) = P(B|A) · P(A) / P(B).

Notăm B = bolnav, T = test pozitiv:

  • P(B) = 0,01 (prevalența), deci P(nu B) = 0,99;
  • P(T|B) = 0,99 (sensibilitatea);
  • P(T|nu B) = 1 - 0,95 = 0,05 (rata de fals pozitivi).

P(T) = 0,99 · 0,01 + 0,05 · 0,99 = 0,0099 + 0,0495 = 0,0594.

P(B|T) = 0,0099 / 0,0594 ≈ 0,167.

Intuitiv, la 10.000 de oameni: 100 sunt bolnavi și 99 au test pozitiv; din 9.900 sănătoși, 5% adică 495 au tot test pozitiv. Din 594 de pozitivi, doar 99 sunt bolnavi.

PYTHON
prev, sens, spec = 0.01, 0.99, 0.95
p_poz = sens * prev + (1 - spec) * (1 - prev)
print(sens * prev / p_poz)   # 0.1667

Legătura cu machine learning este directă: această probabilitate este precizia (precision) unui clasificator. Un model cu recall și specificitate mari poate avea precizie mică dacă clasa pozitivă e rară, de exemplu la detecția fraudei. De aceea pe date dezechilibrate te uiți la precision și recall, nu la acuratețe, iar decizia de prag depinde de prevalență.

Ce urmărește intervievatorul: Verifică raționamentul probabilistic și ignorarea ratei de bază, o greșeală frecventă. Răspunsul intuitiv „99%” este greșit.

25 Junior

Ce este valoarea p și cum o interpretezi corect?

Răspuns scurt: Valoarea p este probabilitatea de a obține un rezultat cel puțin la fel de extrem ca cel observat, presupunând că ipoteza nulă e adevărată. Nu este probabilitatea ca ipoteza nulă să fie adevărată.

Într-un test statistic pornești de la o ipoteză nulă H0 (de exemplu, „noul buton nu schimbă rata de conversie”) și calculezi o statistică din date. Valoarea p răspunde la întrebarea: dacă H0 ar fi adevărată, cât de des aș vedea o diferență cel puțin atât de mare doar din întâmplare?

Dacă p este sub pragul ales dinainte, α (des 0,05), respingi H0 și spui că rezultatul este semnificativ statistic.

PYTHON
from scipy import stats
a = [12.1, 11.8, 12.5, 12.0, 11.9, 12.3, 12.2]
b = [12.6, 12.9, 12.4, 13.1, 12.8, 12.7, 13.0]
t, p = stats.ttest_ind(a, b, equal_var=False)
print(round(p, 5))

Interpretări greșite frecvente:

  • „p = 0,03 înseamnă 3% șanse ca H0 să fie adevărată.” Fals; asta ar cere o abordare bayesiană cu o probabilitate a priori.
  • „p mare dovedește că nu există efect.” Fals; poate eșantionul e prea mic.
  • „p mic înseamnă efect mare sau important.” Fals; cu milioane de observații, diferențe minuscule devin semnificative.

De aceea raportezi întotdeauna și mărimea efectului cu un interval de încredere, stabilești pragul și mărimea eșantionului înainte de experiment și nu testezi zeci de ipoteze până găsești una sub 0,05.

Ce urmărește intervievatorul: Una dintre cele mai frecvente întrebări de statistică. Majoritatea candidaților dau definiția greșită „probabilitatea ca H0 să fie adevărată”.

26 Junior

Ce sunt erorile de tip I și de tip II și ce înseamnă puterea unui test?

Răspuns scurt: Eroarea de tip I este respingerea unei ipoteze nule adevărate (fals pozitiv, probabilitate α); eroarea de tip II este nerespingerea unei ipoteze nule false (fals negativ, probabilitate β). Puterea este 1 - β, șansa de a detecta un efect real.

Gândește-te la un A/B test în care H0 spune „varianta nouă nu e mai bună”.

  • Tip I (α): declari un câștigător când, de fapt, nu există diferență. Cu α = 0,05 accepți ca, în medie, 5% din testele fără efect să pară semnificative.
  • Tip II (β): nu observi o îmbunătățire care chiar există, de obicei pentru că eșantionul e prea mic sau zgomotul e mare.
  • Puterea (1 - β) este probabilitatea de a detecta efectul dacă el are cel puțin o anumită mărime. Valoarea uzuală țintită este 80%.

Puterea crește cu mărimea eșantionului, cu mărimea efectului și cu α, și scade cu varianța datelor. Calculul se face înainte de experiment, ca să știi câți utilizatori îți trebuie:

PYTHON
from statsmodels.stats.power import NormalIndPower
from statsmodels.stats.proportion import proportion_effectsize
efect = proportion_effectsize(0.11, 0.10)   # de la 10% la 11% conversie
n = NormalIndPower().solve_power(effect_size=efect, alpha=0.05, power=0.8)
print(round(n))   # utilizatori necesari în fiecare grup

Cele două erori sunt în tensiune: dacă scazi α ca să reduci fals pozitivii, la același eșantion crește β. Care eroare costă mai mult depinde de context: în screening medical un fals negativ e grav, în lansarea unei funcționalități costisitoare un fals pozitiv poate fi mai scump. Același compromis apare la alegerea pragului unui clasificator.

Ce urmărește intervievatorul: Verifică dacă înțelegi compromisul dintre cele două erori și rolul mărimii eșantionului. Mulți nu au auzit de calculul puterii înainte de test.

27 Junior

Ce înseamnă „corelația nu implică cauzalitate”? Dă un exemplu și spune cum ai putea stabili cauzalitatea.

Răspuns scurt: Două variabile pot varia împreună din cauza unei a treia variabile (confounder), a cauzalității inverse sau a întâmplării. Cauzalitatea se stabilește cel mai sigur prin experimente randomizate, iar din date observaționale cu metode cauzale și ipoteze explicite.

Exemplu: în datele unui magazin online, utilizatorii care folosesc aplicația mobilă cheltuiesc mai mult. Concluzia „aplicația îi face să cheltuiască mai mult” poate fi greșită, pentru că clienții deja fideli și activi sunt cei care instalează aplicația. Variabila ascunsă, „implicarea”, influențează ambele.

Explicații alternative pentru o corelație:

  • Confounder: o a treia variabilă cauzează ambele fenomene.
  • Cauzalitate inversă: B cauzează A, nu invers.
  • Selecție: te uiți doar la un subset filtrat (de exemplu doar clienții care au rămas).
  • Coincidență: cu multe variabile, unele perechi corelează din întâmplare.

Cum stabilești cauzalitatea:

  • Experiment randomizat (A/B test): randomizarea face grupurile comparabile în medie și pe variabilele neobservate. Este standardul de aur.
  • Când experimentul nu e posibil: difference-in-differences (compari evoluția unui grup afectat cu a unuia neafectat), regression discontinuity (în jurul unui prag), variabile instrumentale, propensity score matching. Toate se bazează pe ipoteze care trebuie argumentate.

Mai trebuie spus că și coeficientul Pearson măsoară doar relația liniară: două variabile pot fi strâns legate neliniar și avea corelație aproape zero. La interviu, cel mai bun răspuns propune concret cum ai testa ipoteza, nu doar repetă fraza.

Ce urmărește intervievatorul: Verifică gândirea critică asupra concluziilor din date. Răspunsul slab doar repetă principiul fără exemplu sau metodă.

28 Mid

Ce este un interval de încredere de 95% și cum îl explici unui coleg din business?

Răspuns scurt: Este un interval calculat din eșantion printr-o procedură care, repetată pe multe eșantioane, ar conține valoarea reală în 95% din cazuri. Practic, arată gama de valori plauzibile pentru efect, nu doar o estimare punctuală.

Dacă ai măsurat că varianta nouă crește conversia cu 1,2 puncte procentuale, intervalul de încredere arată cât de sigură e această estimare, de exemplu [0,3; 2,1].

Interpretarea corectă (frecventistă): procedura de construire a intervalului are o rată de acoperire de 95%. Pentru un interval concret, deja calculat, valoarea reală fie e înăuntru, fie nu. Formularea „95% probabilitate ca valoarea să fie în interval” este tehnic greșită în cadrul frecventist, deși e exact ce oferă un interval credibil bayesian.

Pentru o medie, aproximarea uzuală este media ± 1,96 · eroarea standard:

PYTHON
import numpy as np
from scipy import stats
x = np.array([23, 25, 21, 30, 27, 26, 24, 28, 22, 29])
m, se = x.mean(), stats.sem(x)
print(stats.t.interval(0.95, df=len(x) - 1, loc=m, scale=se))

Pe eșantioane mici se folosește distribuția t în loc de normală, ca mai sus.

Pentru un coleg din business: „Estimăm o creștere de 1,2 puncte. Ținând cont de zgomotul din date, creșterea reală e foarte probabil între 0,3 și 2,1. Chiar și în scenariul prudent, câștigăm.” Dacă intervalul ar fi [-0,5; 2,9], ai spune că nu putem exclude că nu există efect și că avem nevoie de mai multe date. Intervalele mai înguste cer eșantioane mai mari, iar lățimea scade cu rădăcina lui n.

Ce urmărește intervievatorul: Verifică înțelegerea incertitudinii și capacitatea de comunicare. Greșeala tipică: interpretarea probabilistică a unui interval deja calculat.

29 Mid

Când folosești un test t, un test chi-pătrat sau un test Mann-Whitney?

Răspuns scurt: Testul t compară mediile a două grupuri pentru o variabilă numerică; chi-pătrat testează asocierea între variabile categoriale (de exemplu conversie da/nu pe variante); Mann-Whitney este alternativa neparametrică când datele numerice sunt puternic asimetrice sau ordinale.

Alegerea testului depinde de tipul variabilei și de ipotezele pe care le poți susține.

  • Testul t pentru două eșantioane independente: variabilă numerică (de exemplu valoarea coșului), două grupuri. Varianta Welch (equal_var=False) nu presupune varianțe egale și e o alegere implicită bună. Datorită teoremei limită centrale, funcționează bine la eșantioane mari chiar dacă datele nu sunt perfect normale.
  • Testul t pereche: aceleași unități măsurate de două ori (înainte și după).
  • Chi-pătrat de independență: două variabile categoriale, cu un tabel de contingență. Cere frecvențe așteptate suficient de mari în fiecare celulă; altfel folosești testul exact Fisher.
  • Mann-Whitney U: compară distribuțiile a două grupuri pe baza rangurilor, robust la outlieri. Nu testează strict mediile, ci dacă valorile dintr-un grup tind să fie mai mari.
  • Pentru mai mult de două grupuri: ANOVA, respectiv Kruskal-Wallis.
PYTHON
from scipy import stats
import numpy as np
tabel = np.array([[120, 880],    # varianta A: convertiți, neconvertiți
                  [150, 850]])   # varianta B
chi2, p, dof, _ = stats.chi2_contingency(tabel)
print(round(p, 4))

a = np.random.default_rng(1).lognormal(3, 1, 300)
b = np.random.default_rng(2).lognormal(3.1, 1, 300)
print(stats.mannwhitneyu(a, b).pvalue)

La interviu contează să spui ce ipoteză testezi și ce presupune testul, nu doar numele funcției.

Ce urmărește intervievatorul: Verifică dacă alegi testul după tipul datelor și ipoteze. Greșeala tipică: test t pe proporții mici fără verificare sau pe date ordinale.

30 Mid

Ce este bootstrap-ul și când îl folosești?

Răspuns scurt: Bootstrap-ul estimează incertitudinea unei statistici reeșantionând datele cu înlocuire de multe ori și recalculând statistica pe fiecare eșantion. E util când nu există o formulă simplă pentru eroarea standard, de exemplu la mediană sau la un raport.

Ideea: eșantionul tău este cea mai bună aproximare a populației. Extragi din el, cu înlocuire, un nou eșantion de aceeași mărime, calculezi statistica dorită și repeți de câteva mii de ori. Distribuția valorilor obținute aproximează distribuția de eșantionare a statisticii.

PYTHON
import numpy as np
rng = np.random.default_rng(42)
timpi = rng.lognormal(mean=1.0, sigma=0.8, size=400)   # durate asimetrice

boot = [np.median(rng.choice(timpi, size=len(timpi), replace=True))
        for _ in range(5000)]
low, high = np.percentile(boot, [2.5, 97.5])
print(np.median(timpi), low, high)

Intervalul dintre percentilele 2,5 și 97,5 este un interval de încredere de 95% (metoda percentilelor). SciPy are și scipy.stats.bootstrap, cu metode mai precise, cum este BCa.

Situații tipice:

  • statistici fără formulă comodă: mediană, percentile, raportul a două medii, diferența de AUC între două modele;
  • metrici de business de tip raport în A/B testing (venit per utilizator, click-uri per sesiune);
  • estimarea variabilității unui model pe setul de test.

Limite: bootstrap-ul presupune observații independente. Dacă datele sunt grupate (mai multe sesiuni per utilizator), reeșantionezi pe utilizatori, nu pe sesiuni (cluster bootstrap), altfel intervalul iese prea îngust. Pentru serii de timp există variante pe blocuri. Nu repară un eșantion mic sau nereprezentativ și funcționează prost pentru statistici extreme, de exemplu maximul.

Ce urmărește intervievatorul: Verifică dacă știi o unealtă practică de inferență. Greșeala tipică: reeșantionarea pe rânduri când unitatea independentă este utilizatorul.

31 Senior

Ai rulat 20 de teste statistice și unul a ieșit semnificativ la p < 0,05. Ce concluzie tragi?

Răspuns scurt: Nicio concluzie fermă: la 20 de teste fără niciun efect real, probabilitatea de a obține cel puțin un rezultat semnificativ doar din întâmplare este de aproximativ 64%. Trebuie corectat pentru comparații multiple, cu Bonferroni, Holm sau controlul FDR.

Fiecare test are o probabilitate α de fals pozitiv. Dacă testele sunt independente și nu există niciun efect real, probabilitatea de a obține cel puțin un rezultat semnificativ este 1 - 0,95^20 ≈ 0,64. Asta se numește rata de eroare pe familie de teste (FWER).

Situația apare des: A/B test cu multe metrici, analiză pe zeci de segmente („funcționează doar pentru utilizatorii de Android din Iași”), sau testarea multor feature-uri. Căutarea până găsești ceva semnificativ se numește p-hacking.

Corecții:

  • Bonferroni: compari fiecare p cu α / m (aici 0,0025). Simplu, dar conservator.
  • Holm: variantă pe pași, la fel de sigură pentru FWER și mai puternică.
  • Benjamini-Hochberg: controlează FDR, proporția așteptată de fals pozitivi printre descoperiri. Potrivit când explorezi multe ipoteze și accepți câteva rezultate false.
PYTHON
from statsmodels.stats.multitest import multipletests
p = [0.01, 0.04, 0.03, 0.20, 0.002]
for metoda in ["bonferroni", "holm", "fdr_bh"]:
    resp, p_corect, _, _ = multipletests(p, alpha=0.05, method=metoda)
    print(metoda, resp)

Dincolo de corecții, abordarea senior este procedurală: stabilești dinainte o metrică principală și câteva metrici de protecție (guardrail), tratezi analizele pe segmente ca explorare și confirmi rezultatele surprinzătoare cu un experiment nou.

Ce urmărește intervievatorul: Verifică maturitatea statistică și rezistența la concluzii false. Mulți raportează fericiți „rezultatul semnificativ” fără să întrebe câte teste s-au făcut.

32 Senior

Ce este estimarea de verosimilitate maximă (MLE) și ce legătură are cu funcțiile de cost din ML?

Răspuns scurt: MLE alege parametrii modelului care fac datele observate cât mai probabile. Multe funcții de cost din ML sunt exact minus logaritmul verosimilității: MSE pentru zgomot gaussian, log loss (entropia încrucișată) pentru clasificare binară.

Presupui un model probabilistic al datelor cu parametri θ. Verosimilitatea L(θ) este probabilitatea (sau densitatea) datelor observate ca funcție de θ. MLE caută θ care maximizează L(θ). Pentru observații independente, verosimilitatea este un produs, așa că se lucrează cu logaritmul, care transformă produsul în sumă și e numeric stabil.

Legături directe cu ML:

  • Regresie liniară: dacă y = wx + zgomot gaussian cu varianță constantă, maximizarea log-verosimilității este echivalentă cu minimizarea sumei pătratelor erorilor. Deci MSE este MLE sub ipoteza de zgomot normal.
  • Regresie logistică: y este Bernoulli cu probabilitatea p = σ(wx). Minus log-verosimilitatea medie este exact log loss, adică entropia încrucișată binară.
  • Clasificare multiclasă: softmax plus entropia încrucișată categorială.
PYTHON
import numpy as np
y = np.array([1, 0, 1, 1])
p = np.array([0.9, 0.2, 0.7, 0.6])
log_loss = -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
print(round(log_loss, 4))   # 0.3196

Regularizarea are și ea o interpretare: este echivalentă cu estimarea MAP (maximum a posteriori) cu o distribuție a priori pe parametri. L2 corespunde unei a priori gaussiene, L1 uneia Laplace.

MLE are proprietăți bune asimptotic, dar pe date puține poate supraajusta, iar dacă modelul presupus e greșit (de exemplu zgomot cu cozi grele), estimarea poate fi sensibilă la outlieri.

Ce urmărește intervievatorul: Verifică dacă înțelegi de unde vin funcțiile de cost, nu doar le folosești. Arată fundamentul teoretic așteptat la nivel senior.

Pregătirea datelor și feature engineering

33 Junior

Cum tratezi valorile lipsă dintr-un set de date?

Răspuns scurt: Întâi înțelegi de ce lipsesc (complet aleator, dependent de alte variabile sau de valoarea însăși), apoi alegi: elimini rânduri sau coloane, imputezi (mediană, mod, model), adaugi un indicator de lipsă sau folosești modele care tratează nativ lipsurile.

Primul pas este diagnosticul: cât lipsește, unde și de ce.

PYTHON
import pandas as pd
df = pd.read_csv("clienti.csv")
print(df.isna().mean().sort_values(ascending=False))   # procent lipsă pe coloană

Tipuri de lipsă, care dictează strategia:

  • MCAR (complet aleator): o eroare tehnică aleatoare. Eliminarea rândurilor nu introduce deplasare, doar pierzi date.
  • MAR: lipsa depinde de alte variabile observate (clienții mai tineri completează mai rar venitul). Imputarea pe baza altor coloane funcționează.
  • MNAR: lipsa depinde chiar de valoarea lipsă (cei cu venit mare nu îl declară). Aici lipsa este ea însăși informație.

Opțiuni:

  • Eliminarea coloanei dacă lipsește aproape tot și nu e esențială; a rândurilor dacă sunt puține.
  • Imputare simplă: mediana pentru numerice (robustă la outlieri), cea mai frecventă valoare sau categoria „Necunoscut” pentru categoriale.
  • Un indicator binar „era lipsă”, care permite modelului să învețe din lipsă.
  • Imputare pe model: KNNImputer, IterativeImputer din scikit-learn.
  • Modele care acceptă nativ NaN: HistGradientBoostingClassifier, LightGBM, XGBoost.

Regula critică: parametrii imputării (de exemplu mediana) se calculează doar pe setul de antrenare, în interiorul unui Pipeline, altfel informație din test ajunge în antrenare.

PYTHON
from sklearn.impute import SimpleImputer
imp = SimpleImputer(strategy="median", add_indicator=True)

Ce urmărește intervievatorul: Verifică dacă pui întrebarea „de ce lipsește?” înainte de a imputa. Greșeala tipică: imputare cu media pe tot setul înainte de split.

34 Junior

Cum identifici și cum tratezi outlierii?

Răspuns scurt: Îi identifici vizual (boxplot, histogramă, scatter) și cu reguli precum IQR sau scorul z robust, apoi decizi dacă sunt erori (corectezi sau elimini) sau valori reale (le păstrezi, le limitezi, transformi datele ori folosești modele robuste).

Un outlier este o valoare neobișnuit de departe de restul. Primul lucru e să-l privești, nu să-l ștergi.

Metode de detecție:

  • Vizual: boxplot, histogramă pe scară logaritmică, grafic de dispersie între două variabile.
  • Regula IQR: valori sub Q1 - 1,5·IQR sau peste Q3 + 1,5·IQR.
  • Scor z: |z| > 3, potrivit doar pentru date aproximativ normale. Varianta robustă folosește mediana și MAD.
  • Multivariat: Isolation Forest sau Local Outlier Factor, pentru puncte care sunt normale pe fiecare coloană, dar neobișnuite în combinație.
PYTHON
import pandas as pd
s = pd.Series([120, 130, 125, 140, 118, 135, 9000])
q1, q3 = s.quantile([0.25, 0.75])
iqr = q3 - q1
print(s[(s < q1 - 1.5 * iqr) | (s > q3 + 1.5 * iqr)])   # 9000

Tratamentul depinde de cauză:

  • Eroare de date (vârstă 250, preț negativ, unitate greșită): corectezi dacă poți, altfel tratezi ca valoare lipsă.
  • Valoare reală, dar extremă (un client corporate care cumpără de 100 de ori mai mult): o păstrezi; poți aplica winsorizare (limitezi la percentila 1 și 99), transformare logaritmică sau modele robuste (arbori, pierdere Huber).
  • Uneori outlierii sunt chiar ținta, de exemplu la detecția fraudei.

Ca la orice transformare, pragurile se calculează pe setul de antrenare, iar decizia se documentează, pentru că eliminarea „valorilor incomode” poate schimba concluziile.

Ce urmărește intervievatorul: Verifică judecata, nu doar formula IQR. Răspunsul slab elimină automat orice valoare extremă.

35 Junior

Care este diferența dintre standardizare și normalizare min-max și pentru ce modele contează scalarea?

Răspuns scurt: Standardizarea transformă fiecare variabilă la medie 0 și deviație standard 1; normalizarea min-max o aduce în intervalul [0, 1]. Scalarea contează pentru modele bazate pe distanțe sau gradient (KNN, SVM, k-means, regresie regularizată, rețele neuronale), nu pentru arbori.

Variabilele au adesea scale foarte diferite: vârsta între 18 și 80, venitul între 2.000 și 50.000. Modelele care calculează distanțe sau combină variabile liniar sub penalizare sunt dominate de variabila cu valori mari.

  • Standardizare (StandardScaler): z = (x - medie) / deviație. Alegerea implicită pentru regresii, SVM, PCA, rețele.
  • Min-max (MinMaxScaler): (x - min) / (max - min). Util când ai nevoie de un interval fix, de exemplu pentru intensitatea pixelilor. Este foarte sensibil la outlieri: o singură valoare extremă comprimă restul.
  • RobustScaler: folosește mediana și IQR, potrivit cu outlieri.
PYTHON
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score

X, y = load_wine(return_X_y=True)
fara = cross_val_score(KNeighborsClassifier(), X, y, cv=5).mean()
cu = cross_val_score(make_pipeline(StandardScaler(), KNeighborsClassifier()), X, y, cv=5).mean()
print(round(fara, 3), round(cu, 3))   # scalarea crește clar scorul

Arborii de decizie, Random Forest și gradient boosting nu sunt afectați de scalare, pentru că împart datele după praguri pe câte o singură variabilă.

Ca și la imputare, scaler-ul se potrivește (fit) doar pe datele de antrenare și se aplică (transform) pe validare și test, ideal în interiorul unui Pipeline, ca să nu existe scurgere de informație.

Ce urmărește intervievatorul: Verifică dacă știi când contează scalarea și de ce. Greșeala tipică: scalarea întregului set înainte de împărțirea în train și test.

36 Junior

Cum codifici variabilele categoriale pentru un model? Compară one-hot, ordinal și target encoding.

Răspuns scurt: One-hot creează câte o coloană binară pe categorie și nu impune ordine; ordinal encoding transformă categoriile în numere, potrivit doar când există ordine reală sau pentru arbori; target encoding înlocuiește categoria cu media țintei, util la cardinalitate mare, dar riscant pentru leakage.

Modelele lucrează cu numere, deci textul categorial trebuie transformat.

  • One-hot encoding: „oraș” cu valorile Cluj, Iași, Timișoara devine trei coloane 0/1. Nu introduce o ordine falsă. Problema apare la cardinalitate mare (mii de coduri poștale): multe coloane rare. Pentru modelele liniare se elimină de obicei o coloană (drop="first") ca să eviți coliniaritatea perfectă.
  • Ordinal encoding: mic=0, mediu=1, mare=2. Corect când ordinea există. Pentru modele liniare, a codifica orașele ca 0, 1, 2 e greșit, pentru că modelul ar presupune că Iași este „între” Cluj și Timișoara. Arborii tolerează mai bine această codificare.
  • Target encoding: fiecare categorie primește media țintei pentru acea categorie (de exemplu rata de churn pe oraș). Compact și puternic la cardinalitate mare, dar dacă îl calculezi pe aceleași rânduri pe care antrenezi, modelul vede indirect ținta. Se folosesc netezire spre media globală și calcul out-of-fold.
PYTHON
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, TargetEncoder
import pandas as pd
df = pd.DataFrame({"oras": ["Cluj", "Iași", "Cluj", "Arad"], "marime": ["mic", "mare", "mediu", "mic"]})
ohe = OneHotEncoder(handle_unknown="ignore").fit(df[["oras"]])
ord_ = OrdinalEncoder(categories=[["mic", "mediu", "mare"]]).fit(df[["marime"]])

TargetEncoder există în scikit-learn din versiunea 1.3 și face intern cross-fitting în fit_transform. handle_unknown="ignore" evită erorile când în producție apare o categorie nouă.

Ce urmărește intervievatorul: Verifică dacă înțelegi efectul codificării asupra modelului. Greșeala tipică: label encoding pe categorii nominale pentru o regresie liniară.

37 Junior

Ai un DataFrame cu comenzi și unul cu clienți. Cum calculezi în pandas valoarea medie a comenzilor pe oraș, doar pentru clienții activi?

Răspuns scurt: Unești tabelele cu merge pe cheia clientului, filtrezi clienții activi, apoi grupezi cu groupby('oras') și agregi cu mean. Verifici înainte că cheia e unică în tabelul de clienți, ca să nu multiplici rândurile.

PYTHON
import pandas as pd

clienti = pd.DataFrame({
    "client_id": [1, 2, 3, 4],
    "oras": ["Cluj", "Iași", "Cluj", "Brașov"],
    "activ": [True, True, False, True],
})
comenzi = pd.DataFrame({
    "comanda_id": [10, 11, 12, 13, 14],
    "client_id": [1, 1, 2, 3, 4],
    "valoare": [200.0, 300.0, 150.0, 500.0, 90.0],
})

rez = (
    comenzi.merge(clienti, on="client_id", how="inner", validate="many_to_one")
           .query("activ")
           .groupby("oras", as_index=False)
           .agg(medie=("valoare", "mean"), nr_comenzi=("comanda_id", "count"))
           .sort_values("medie", ascending=False)
)
print(rez)

Rezultatul: Cluj 250 (comenzile clientului 1), Iași 150, Brașov 90; clientul 3 e inactiv și dispare.

Detalii care contează:

  • validate="many_to_one" aruncă eroare dacă un client_id apare de două ori în clienti, prevenind multiplicarea tăcută a rândurilor.
  • how="inner" elimină comenzile fără client; cu how="left" și indicator=True poți vedea câte comenzi nu au corespondent.
  • Agregarea cu nume (medie=("valoare", "mean")) produce coloane clare, fără MultiIndex.
  • Întrebarea are o ambiguitate: media pe comandă sau media pe client? Dacă un client are 100 de comenzi, el domină media pe comandă. Merită să întrebi; varianta pe client cere întâi un groupby("client_id").

Ce urmărește intervievatorul: Exercițiu practic tipic de pandas. Se urmăresc corectitudinea join-ului și clarificarea cerinței, nu doar sintaxa.

38 Junior

Care este diferența dintre loc și iloc în pandas și de ce apare SettingWithCopyWarning?

Răspuns scurt: loc selectează după etichete (numele indexului și al coloanelor), iloc după poziții întregi. Avertismentul apare când modifici un rezultat obținut prin indexare înlănțuită, unde pandas nu poate garanta dacă scrii în original sau într-o copie.

PYTHON
import pandas as pd
df = pd.DataFrame({"pret": [10, 20, 30], "stoc": [5, 0, 2]}, index=["a", "b", "c"])

print(df.loc["b", "pret"])      # 20, după etichetă
print(df.iloc[1, 0])            # 20, după poziție
print(df.loc["a":"b"])          # include "b": la loc capătul e inclus
print(df.iloc[0:2])             # exclude poziția 2, ca în Python

Diferența de capăt la feliere e o sursă clasică de erori: loc include capătul, iloc nu.

SettingWithCopyWarning apare la indexare înlănțuită:

PYTHON
df[df["stoc"] == 0]["pret"] = 0          # avertisment, poate să nu modifice df
df.loc[df["stoc"] == 0, "pret"] = 0      # corect, o singură operație

Prima linie face două operații: filtrarea produce un obiect intermediar (posibil o copie), iar atribuirea se face pe acel obiect. Dacă e o copie, df rămâne neschimbat, fără eroare. Varianta cu loc[rânduri, coloană] scrie direct în df.

Când vrei intenționat un subset separat pe care să-l modifici, fă copia explicit: sub = df[df["stoc"] > 0].copy(). Din pandas 2.x poți activa Copy-on-Write, iar în pandas 3.0 este comportamentul implicit; cu el, indexarea înlănțuită nu mai modifică niciodată originalul, iar avertismentul dispare, pentru că regula devine clară. Codul cu loc funcționează corect în toate versiunile.

Ce urmărește intervievatorul: Verifică experiența reală cu pandas. Mulți ignoră avertismentul și ajung cu modificări care nu s-au aplicat.

39 Junior

Primești un set de date nou. Ce pași faci în analiza exploratorie (EDA) înainte de a construi un model?

Răspuns scurt: Înțelegi întrebarea și ce reprezintă un rând, verifici forma, tipurile, lipsurile și duplicatele, studiezi distribuția țintei și a variabilelor, relațiile cu ținta, posibilele scurgeri de informație și consistența în timp. Notezi ipotezele care vor ghida modelarea.

Un EDA bun e ghidat de întrebarea de business, nu o listă de grafice generate automat.

  • Context: ce reprezintă un rând (un client, o tranzacție, o zi)? Cum s-au colectat datele? Ce prezicem și în ce moment al procesului ar fi disponibilă predicția?
  • Structură: df.shape, df.dtypes, df.head(), df.describe(include="all"). Coloane numerice citite ca text, date calendaristice ca șiruri.
  • Calitate: procent de lipsuri pe coloană, duplicate (df.duplicated().sum(), mai ales pe cheia presupus unică), valori imposibile, categorii scrise diferit („Cluj”, „cluj ”).
  • Ținta: distribuția ei. Pentru clasificare, cât de dezechilibrată e; pentru regresie, dacă e asimetrică și ar beneficia de logaritm.
  • Variabile: histograme, valori rare, cardinalitatea categoriilor.
  • Relații cu ținta: rata țintei pe categorii, corelații, grafice pe intervale. O variabilă care prezice aproape perfect ținta e de obicei suspectă de leakage.
  • Timp: cum evoluează volumul și ținta în timp. Schimbările bruște pot indica modificări de proces sau de colectare.
  • Corelații între variabile: redundanțe care contează pentru modele liniare și pentru interpretare.
PYTHON
import pandas as pd
df = pd.read_csv("date.csv", parse_dates=["data"])
print(df.isna().mean().round(3))
print(df["tinta"].value_counts(normalize=True))
print(df.groupby(df["data"].dt.to_period("M"))["tinta"].mean())

La final rămâi cu o listă scurtă de constatări și decizii: ce curăți, ce variabile construiești, ce validare folosești.

Ce urmărește intervievatorul: Verifică metoda de lucru și curiozitatea față de date. Răspunsul slab sare direct la „antrenez un XGBoost”.

40 Mid

Ce este data leakage? Dă exemple și spune cum îl previi.

Răspuns scurt: Data leakage înseamnă că modelul folosește la antrenare informații care nu vor fi disponibile la momentul predicției reale, așa că scorul din evaluare e umflat și modelul dezamăgește în producție. Se previne cu split corect, pipeline-uri și verificarea momentului în care fiecare variabilă devine cunoscută.

Două forme principale:

  • Leakage din țintă: o variabilă conține indirect răspunsul. Exemple: pentru predicția churn, coloana „data_anulării_contului” sau „motiv_retur”; pentru predicția unei boli, un tratament care se administrează doar după diagnostic. Variabila e corelată cu ținta, dar apare în date după eveniment.
  • Leakage din procesul de antrenare: informații din test ajung în antrenare. Exemple: scalare, imputare sau selecție de feature-uri făcute pe tot setul înainte de split; target encoding fără out-of-fold; duplicate sau aceiași utilizatori în train și test; split aleator pe date temporale, care permite modelului să „vadă viitorul”.

Semnale de alarmă: un scor nerealist de bun, o singură variabilă cu importanță uriașă, diferență mare între validare și primele rezultate din producție.

Prevenire:

PYTHON
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score, GroupKFold

pipe = Pipeline([("scaler", StandardScaler()), ("model", LogisticRegression(max_iter=1000))])
# scores = cross_val_score(pipe, X, y, cv=GroupKFold(n_splits=5), groups=user_id)
  • Toate transformările stau în Pipeline, ca să se învețe doar pe fold-ul de antrenare.
  • Split pe grupuri (GroupKFold) când un utilizator are mai multe rânduri și split temporal când predicția privește viitorul.
  • Pentru fiecare feature întrebi: „la momentul predicției, valoarea asta ar fi cunoscută?”. Pentru date istorice, construiești feature-urile point-in-time, cu datele de până la acel moment.

Ce urmărește intervievatorul: Una dintre cele mai importante întrebări practice. Candidații cu experiență reală dau exemple din proiectele lor; cei fără confundă leakage cu overfitting.

41 Mid

Ce feature-uri ai construi dintr-o coloană de tip dată și oră și dintr-un istoric de tranzacții al unui client?

Răspuns scurt: Din dată: componente calendaristice (zi a săptămânii, oră, lună, sărbători), eventual codificate ciclic, și durate față de evenimente. Din istoric: agregări pe ferestre de timp (recență, frecvență, valoare, tendințe), calculate strict cu date anterioare momentului predicției.

Un timestamp brut nu spune mare lucru unui model. Din el extragi:

  • componente: ora, ziua săptămânii, ziua lunii, luna, weekend sau nu, sărbătoare legală, începutul sau sfârșitul lunii (relevant pentru salarii);
  • codificare ciclică pentru modele liniare și rețele, ca ora 23 să fie aproape de ora 0: sin(2π·ora/24) și cos(2π·ora/24);
  • durate: zile de la înregistrare, de la ultima autentificare, până la expirarea abonamentului.

Pentru un istoric de tranzacții, formatul clasic este RFM plus tendințe:

PYTHON
import pandas as pd
tx = pd.read_csv("tranzactii.csv", parse_dates=["data"])
ref = pd.Timestamp("2026-09-30")              # momentul predicției
ist = tx[tx["data"] < ref]

def agreg(zile):
    f = ist[ist["data"] >= ref - pd.Timedelta(days=zile)]
    return f.groupby("client_id")["suma"].agg(["count", "sum", "mean"]).add_suffix(f"_{zile}z")

feat = pd.concat([agreg(30), agreg(90)], axis=1).fillna(0)
feat["recenta_zile"] = (ref - ist.groupby("client_id")["data"].max()).dt.days
feat["trend"] = feat["sum_30z"] / (feat["sum_90z"] / 3 + 1)
  • Recență: zile de la ultima tranzacție.
  • Frecvență și valoare pe ferestre de 7, 30, 90 de zile.
  • Tendință: raportul dintre activitatea recentă și cea mai veche, un semnal bun pentru churn.
  • Diversitate: număr de categorii distincte, procentul de tranzacții cu reducere.

Punctul critic este filtrul data < ref: toate agregările folosesc doar trecutul față de momentul predicției. Dacă antrenezi pe mai multe momente de referință, fiecare rând are propriul ref.

Ce urmărește intervievatorul: Verifică creativitatea în feature engineering și disciplina temporală. Greșeala tipică: agregări pe tot istoricul, inclusiv perioada de după momentul predicției.

42 Mid

Cum lucrezi cu un set de date foarte dezechilibrat, de exemplu 1% fraudă și 99% tranzacții normale?

Răspuns scurt: Alegi metrici potrivite (precision, recall, PR AUC), păstrezi proporțiile în split cu stratificare, folosești ponderi pe clase sau reeșantionare doar pe datele de antrenare și alegi pragul de decizie după costul real al erorilor.

Pe un astfel de set, un model care spune mereu „normal” are acuratețe 99% și e complet inutil. Primul pas este metrica.

  • Metrici: precision, recall, F1 pe clasa minoritară, PR AUC (average precision), care e mai informativă decât ROC AUC când pozitivii sunt rari. Ideal, transformi erorile în cost: cât costă o fraudă ratată versus o tranzacție bună blocată.
  • Split stratificat: train_test_split(..., stratify=y) și StratifiedKFold, ca fiecare fold să aibă pozitivi. Pentru fraudă e frecvent nevoie și de split temporal.
  • Ponderi pe clase: class_weight="balanced" în multe modele scikit-learn sau scale_pos_weight în XGBoost. Simplu și adesea suficient.
  • Reeșantionare: undersampling pe clasa majoritară, oversampling sau SMOTE (din biblioteca imbalanced-learn). Se aplică numai pe datele de antrenare, în interiorul validării încrucișate; aplicată înainte de split, umflă rezultatele.
  • Pragul de decizie: modelul produce probabilități; pragul 0,5 rar e optim. Alegi pragul pe validare, după costuri sau după un recall minim cerut.
PYTHON
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import average_precision_score, precision_recall_curve
model = LogisticRegression(class_weight="balanced", max_iter=1000)
# model.fit(X_tr, y_tr); p = model.predict_proba(X_val)[:, 1]
# print(average_precision_score(y_val, p))
# prec, rec, praguri = precision_recall_curve(y_val, p)

Atenție: ponderile și reeșantionarea deformează probabilitățile; dacă ai nevoie de probabilități reale (de exemplu pentru un calcul de cost), le recalibrezi după antrenare.

Ce urmărește intervievatorul: Problemă foarte frecventă în practică. Greșeala tipică: raportarea acurateței sau aplicarea SMOTE înainte de împărțirea datelor.

43 Mid

Ce este „blestemul dimensionalității” și cum te ajută PCA?

Răspuns scurt: Pe măsură ce crește numărul de variabile, datele devin rare în spațiu, distanțele își pierd sensul și modelele au nevoie de mult mai multe exemple. PCA reduce dimensiunea proiectând datele pe câteva direcții ortogonale care păstrează cea mai mare parte din varianță.

În dimensiuni mari apar fenomene contraintuitive: volumul spațiului crește exponențial, deci punctele sunt tot mai rare; distanța până la cel mai apropiat vecin devine aproape egală cu distanța până la cel mai îndepărtat; modelele bazate pe distanțe (KNN, k-means) se degradează, iar orice model are mai multe ocazii să găsească tipare false.

PCA (Principal Component Analysis) găsește direcțiile de varianță maximă în date. Prima componentă principală este direcția de-a lungul căreia datele variază cel mai mult, a doua este perpendiculară pe prima și captează următoarea cea mai mare varianță etc. Păstrezi primele k componente.

PYTHON
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

X, _ = load_digits(return_X_y=True)          # 64 de variabile
Xs = StandardScaler().fit_transform(X)
pca = PCA(n_components=0.95).fit(Xs)         # păstrează 95% din varianță
print(pca.n_components_)                      # mult mai puține decât 64

Lucruri de știut:

  • PCA cere date scalate, altfel domină variabila cu unitatea cea mai mare.
  • Este o metodă liniară și nesupervizată: maximizează varianța, nu predictibilitatea țintei, deci poate elimina exact direcția utilă.
  • Componentele sunt combinații de variabile și se interpretează greu.
  • Pentru vizualizare se folosesc des t-SNE sau UMAP, dar distanțele dintre grupuri din acele grafice nu trebuie interpretate literal.

Alternative la PCA: selecția de feature-uri, regularizarea L1 sau modele care tolerează multe variabile, cum sunt cele bazate pe arbori.

Ce urmărește intervievatorul: Verifică înțelegerea geometrică și limitele PCA. Mulți uită că PCA cere scalare și că nu ține cont de țintă.

44 Senior

Ai 2.000 de feature-uri și 10.000 de rânduri. Cum alegi ce feature-uri păstrezi?

Răspuns scurt: Combini filtre ieftine (variabile constante, duplicate, corelații foarte mari), metode bazate pe model (L1, importanță prin permutare, eliminare recursivă) și validare: orice selecție se face în interiorul validării încrucișate, altfel scorul final este optimist.

Scopul selecției: model mai simplu, mai rapid, mai stabil și mai ușor de întreținut, cu performanță egală sau mai bună. Abordare pe etape:

  • Curățare: elimini variabile constante sau aproape constante, duplicate exacte, coloane cu lipsuri masive și pe cele suspecte de leakage.
  • Redundanță: dintre perechile foarte corelate păstrezi una, de preferat pe cea mai ieftină sau mai ușor de explicat.
  • Filtre univariate: informație mutuală sau teste statistice față de țintă. Rapide, dar ignoră interacțiunile.
  • Metode încorporate: regresie logistică cu L1, care duce coeficienți la zero; importanța din gradient boosting.
  • Metode wrapper: eliminare recursivă (RFECV) sau selecție secvențială. Costisitoare, dar țin cont de model.
  • Importanță prin permutare pe date de validare: măsoară cât scade scorul când amesteci o coloană. Mai de încredere decât importanța pe bază de impuritate, care favorizează variabilele cu multe valori.
PYTHON
from sklearn.pipeline import Pipeline
from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import cross_val_score

pipe = Pipeline([
    ("sel", SelectFromModel(LogisticRegression(penalty="l1", solver="liblinear", C=0.1))),
    ("model", HistGradientBoostingClassifier()),
])
# cross_val_score(pipe, X, y, cv=5, scoring="roc_auc")

Ideea senior: selecția este parte din model. Dacă alegi feature-urile pe tot setul și abia apoi validezi, ai leakage. Mai merită verificată și stabilitatea: dacă la fiecare fold se aleg alte variabile, semnalul e slab. Iar în producție fiecare feature are un cost de calcul, monitorizare și întreținere.

Ce urmărește intervievatorul: Verifică maturitatea în construirea modelelor reale. Greșeala tipică: selecție pe tot setul înainte de validare, care umflă rezultatul.

Fundamente de machine learning

45 Junior

Care este diferența dintre învățarea supervizată, nesupervizată și prin recompensă (reinforcement learning)?

Răspuns scurt: În învățarea supervizată ai exemple cu răspuns cunoscut (etichete) și înveți să-l prezici; în cea nesupervizată nu ai etichete și cauți structură (grupuri, dimensiuni ascunse); în reinforcement learning un agent învață acțiuni prin încercare și recompense.

  • Supervizată: datele au intrări X și o țintă y. Dacă y este numeric, e regresie (prețul unei locuințe); dacă y este o categorie, e clasificare (spam sau nu, churn sau nu). Exemple de modele: regresie liniară și logistică, arbori, gradient boosting, rețele neuronale.
  • Nesupervizată: ai doar X. Cauți structură: clustering (segmente de clienți cu k-means), reducerea dimensiunii (PCA), detecția anomaliilor (Isolation Forest), reguli de asociere (produse cumpărate împreună).
  • Reinforcement learning: un agent interacționează cu un mediu, ia acțiuni și primește recompense, învățând o politică ce maximizează recompensa pe termen lung. Exemple: jocuri, robotică, unele sisteme de recomandare și licitare. E mai rar în rolurile de data scientist obișnuite.

Există și variante intermediare:

  • Semi-supervizată: puține etichete și multe date neetichetate.
  • Auto-supervizată: modelul își creează singur sarcina din date, de exemplu prezice cuvântul următor. Așa se pre-antrenează modelele mari de limbaj.
PYTHON
from sklearn.linear_model import LogisticRegression   # supervizat
from sklearn.cluster import KMeans                    # nesupervizat
# LogisticRegression().fit(X, y)   are nevoie de y
# KMeans(n_clusters=4).fit(X)      doar X

La interviu e util să legi tipul de problemă de business: „vrem să știm cine pleacă” e clasificare supervizată, dacă avem istoric de plecări; „vrem să înțelegem tipurile de clienți” e clustering.

Ce urmărește intervievatorul: Întrebare de deschidere pentru a verifica vocabularul. Contează să dai exemple concrete și să recunoști tipul de problemă dintr-o cerință de business.

46 Junior

De ce împarți datele în train, validation și test? Ce rol are fiecare?

Răspuns scurt: Pe train modelul învață parametrii, pe validation alegi hiperparametrii și compari variante, iar test se folosește o singură dată, la final, pentru o estimare nepărtinitoare a performanței pe date noi.

Scopul unui model este să funcționeze pe date pe care nu le-a văzut. Dacă evaluezi pe aceleași date pe care ai antrenat, măsori memorarea, nu generalizarea.

  • Train: modelul își ajustează parametrii (coeficienți, praguri de split, ponderi).
  • Validation: compari modele, alegi hiperparametrii (adâncimea arborelui, regularizarea), pragul de decizie și feature-urile. Pentru că iei decizii pe baza lui, scorul de validare devine treptat optimist.
  • Test: un set ținut deoparte până la final. Îl folosești o dată, după ce toate deciziile sunt luate. Dacă te întorci și schimbi modelul pentru că testul a ieșit prost, testul devine practic încă un set de validare.
PYTHON
from sklearn.model_selection import train_test_split
X_tmp, X_test, y_tmp, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)
X_tr, X_val, y_tr, y_val = train_test_split(X_tmp, y_tmp, test_size=0.25, stratify=y_tmp, random_state=42)
# rezultă aproximativ 60% / 20% / 20%

Pe seturi mici, în loc de un set de validare fix folosești validare încrucișată pe partea de antrenare și păstrezi doar testul separat.

Modul în care împarți contează la fel de mult ca proporțiile: stratificat pentru clase dezechilibrate, temporal când prezici viitorul (antrenezi pe ianuarie-august, testezi pe septembrie) și pe grupuri când același client apare de mai multe ori. Setul de test trebuie să semene cu datele pe care modelul le va vedea în producție.

Ce urmărește intervievatorul: Verifică înțelegerea evaluării corecte. Greșeala tipică: tuning repetat pe setul de test, care umflă scorul raportat.

47 Junior

Ce sunt overfitting-ul și underfitting-ul și cum le recunoști?

Răspuns scurt: Overfitting înseamnă că modelul a memorat zgomotul din antrenare: scor foarte bun pe train, mult mai slab pe validare. Underfitting înseamnă că modelul e prea simplu pentru tipar: scor slab pe ambele. Le recunoști comparând erorile de antrenare și de validare.

Un model bun captează tiparul real și ignoră zgomotul.

  • Underfitting: modelul nu poate reprezenta relația. Exemplu: o dreaptă pentru o relație curbă. Simptom: eroare mare și pe antrenare, și pe validare, cu diferență mică între ele.
  • Overfitting: modelul e prea flexibil față de cantitatea de date. Exemplu: un arbore fără limită de adâncime, cu o frunză pentru fiecare exemplu. Simptom: eroare foarte mică pe antrenare, mult mai mare pe validare.
PYTHON
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_tr, X_val, y_tr, y_val = train_test_split(X, y, random_state=0)
for d in [1, 3, None]:
    m = DecisionTreeClassifier(max_depth=d, random_state=0).fit(X_tr, y_tr)
    print(d, round(m.score(X_tr, y_tr), 3), round(m.score(X_val, y_val), 3))

Adâncimea 1 tinde spre underfitting, iar arborele nelimitat atinge 100% pe train, cu validare mai slabă.

Remedii pentru overfitting: mai multe date, model mai simplu, regularizare (L1, L2, limitarea adâncimii, dropout), mai puține feature-uri zgomotoase, early stopping, ansambluri ca Random Forest.

Remedii pentru underfitting: model mai complex, feature-uri mai bune sau interacțiuni, mai puțină regularizare, antrenare mai lungă.

Un instrument practic sunt curbele de învățare și de validare, care arată erorile în funcție de mărimea setului sau de un hiperparametru.

Ce urmărește intervievatorul: Întrebare de bază, aproape garantată. Se verifică dacă știi să diagnostichezi din cifre și ce remedii aplici.

48 Junior

Explică compromisul bias-variance.

Răspuns scurt: Eroarea de predicție pe date noi se descompune în bias (eroare din ipoteze prea simple), varianță (sensibilitate la eșantionul de antrenare) și zgomot ireductibil. Modelele mai complexe scad bias-ul și cresc varianța; cauți complexitatea care minimizează suma.

Imaginează-ți că antrenezi același tip de model pe multe seturi de date diferite extrase din aceeași populație.

  • Bias: cât de departe este, în medie, predicția modelului de valoarea reală. Un model liniar pe o relație neliniară are bias mare: oricâte date i-ai da, rămâne greșit sistematic.
  • Varianța: cât de mult se schimbă predicțiile de la un set de antrenare la altul. Un arbore adânc are varianță mare: câteva puncte diferite schimbă complet structura.
  • Zgomotul: variabilitatea din date pe care niciun model nu o poate explica.

Pentru pierderea pătratică, eroarea așteptată = bias² + varianță + zgomot.

Legătura cu overfitting: bias mare înseamnă de obicei underfitting, varianță mare înseamnă overfitting.

Cum controlezi fiecare componentă:

  • reduci varianța cu mai multe date, regularizare, model mai simplu sau medierea mai multor modele (bagging, Random Forest);
  • reduci bias-ul cu modele mai flexibile, feature-uri mai bune sau boosting, care corectează succesiv erorile.
PYTHON
# Exemplu intuitiv: KNN
# k = 1   -> bias mic, varianță mare (urmează fiecare punct)
# k = 200 -> bias mare, varianță mică (aproape media globală)
from sklearn.neighbors import KNeighborsRegressor
modele = [KNeighborsRegressor(n_neighbors=k) for k in (1, 15, 200)]

Observație la zi: rețelele neuronale foarte mari pot generaliza bine deși au mult mai mulți parametri decât exemple (fenomenul „double descent”), deci curba în formă de U nu e o lege universală. Ca intuiție de bază pentru modelele clasice însă, compromisul rămâne valabil și util.

Ce urmărește intervievatorul: Întrebare teoretică clasică. Se verifică dacă poți lega conceptul de decizii practice, nu doar recita definiția.

49 Junior

Ce este validarea încrucișată k-fold și de ce e mai bună decât un singur split?

Răspuns scurt: Datele se împart în k părți; modelul se antrenează de k ori pe k-1 părți și se evaluează pe partea rămasă, iar scorurile se mediază. Folosește toate datele și pentru antrenare, și pentru evaluare, și arată cât de stabil e scorul.

Cu un singur split, scorul depinde de norocul împărțirii: un set de validare mic poate fi, întâmplător, mai ușor sau mai greu. K-fold reduce această variabilitate.

Procedura pentru k = 5: împarți datele în 5 bucăți egale; la fiecare din cele 5 iterații, o bucată e validare și celelalte patru sunt antrenare; raportezi media și deviația standard a celor 5 scoruri.

PYTHON
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

X, y = load_breast_cancer(return_X_y=True)
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scoruri = cross_val_score(pipe, X, y, cv=cv, scoring="roc_auc")
print(scoruri.round(3), scoruri.mean().round(3), scoruri.std().round(3))

Detalii importante:

  • Stratificat pentru clasificare, ca fiecare fold să aibă aceeași proporție de clase.
  • Preprocesarea stă în Pipeline, ca să fie învățată separat în fiecare fold.
  • Deviația standard dintre fold-uri spune dacă o diferență de 0,005 între două modele este reală sau zgomot.
  • Valori uzuale: k = 5 sau 10. Leave-one-out are varianță mare și e costisitor.
  • Pentru date temporale sau grupate, k-fold aleator dă rezultate optimiste; folosești TimeSeriesSplit sau GroupKFold.

Validarea încrucișată estimează performanța procedurii de modelare. Modelul final se reantrenează apoi pe toate datele de antrenare.

Ce urmărește intervievatorul: Verifică înțelegerea evaluării robuste. Greșeala tipică: preprocesare făcută înainte de cross-validation, în afara pipeline-ului.

50 Junior

Care este diferența dintre regularizarea L1 (Lasso) și L2 (Ridge)?

Răspuns scurt: Ambele adaugă la funcția de cost o penalizare pentru coeficienți mari, ca să reducă overfitting-ul. L1 penalizează suma valorilor absolute și duce unii coeficienți exact la zero (selecție de feature-uri); L2 penalizează suma pătratelor și micșorează coeficienții fără să-i anuleze.

Regularizarea adaugă la eroare un termen care pedepsește complexitatea:

  • Ridge (L2): cost = eroare + α · Σ w². Coeficienții se micșorează uniform spre zero, dar rămân de obicei nenuli. Funcționează bine când multe variabile contribuie puțin și când variabilele sunt corelate, pentru că distribuie ponderea între ele.
  • Lasso (L1): cost = eroare + α · Σ |w|. Geometric, penalizarea are „colțuri” pe axe, așa că soluția optimă are des coeficienți exact zero. Rezultă un model rar (sparse), cu selecție automată de variabile. Dintre variabilele corelate, tinde să aleagă una arbitrar.
  • Elastic Net: combină cele două, util când ai multe variabile corelate și vrei și selecție.
PYTHON
import numpy as np
from sklearn.datasets import make_regression
from sklearn.linear_model import Lasso, Ridge
from sklearn.preprocessing import StandardScaler

X, y = make_regression(n_samples=200, n_features=30, n_informative=5, noise=10, random_state=0)
X = StandardScaler().fit_transform(X)
print((Lasso(alpha=1.0).fit(X, y).coef_ == 0).sum())   # mulți coeficienți zero
print((Ridge(alpha=1.0).fit(X, y).coef_ == 0).sum())   # 0

Practic:

  • Variabilele trebuie scalate, altfel penalizarea afectează inegal coeficienții.
  • Puterea penalizării (α în Lasso/Ridge; în LogisticRegression parametrul C este inversul ei, deci un C mic înseamnă regularizare puternică) se alege prin validare încrucișată, de exemplu cu LassoCV sau RidgeCV.
  • Interceptul nu se penalizează.

Ce urmărește intervievatorul: Întrebare foarte frecventă. Se verifică dacă știi efectul practic (L1 anulează coeficienți) și dacă îți amintești de scalare.

51 Junior

Cum funcționează gradient descent și ce se întâmplă dacă learning rate-ul e prea mare sau prea mic?

Răspuns scurt: Gradient descent ajustează parametrii pas cu pas în direcția opusă gradientului funcției de cost, adică spre scăderea cea mai rapidă a erorii. Un learning rate prea mare face antrenarea să oscileze sau să diverge, unul prea mic o face foarte lentă.

Funcția de cost măsoară cât de greșit este modelul pentru parametrii actuali. Gradientul este vectorul derivatelor parțiale și arată direcția în care costul crește cel mai repede. La fiecare pas: w = w - η · gradient, unde η este learning rate-ul.

PYTHON
import numpy as np
rng = np.random.default_rng(0)
x = rng.uniform(0, 10, 100)
y = 3 * x + 5 + rng.normal(0, 1, 100)

w, b, lr = 0.0, 0.0, 0.01
for _ in range(2000):
    pred = w * x + b
    grad_w = 2 * np.mean((pred - y) * x)
    grad_b = 2 * np.mean(pred - y)
    w, b = w - lr * grad_w, b - lr * grad_b
print(round(w, 2), round(b, 2))   # aproape 3 și 5

Dacă pui lr = 0.1 în acest exemplu, valorile explodează: pașii sar peste minim și cresc la fiecare iterație. Cu lr = 0.0001, după 2000 de pași modelul e încă departe de soluție.

Variante:

  • Batch: gradientul pe toate datele; stabil, dar scump.
  • Stochastic (SGD): pe un singur exemplu; zgomotos, dar rapid.
  • Mini-batch: pe loturi de zeci sau sute de exemple; standardul în deep learning.
  • Optimizatoare adaptive ca Adam ajustează pasul pentru fiecare parametru și folosesc momentum.

Practic: variabilele scalate fac suprafața de cost mai „rotundă” și convergența mai rapidă, iar programele de learning rate (scădere treptată, warmup) ajută la rețele mari. Pentru funcții neconvexe, gradient descent găsește un minim local, nu neapărat global.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de antrenare din spatele majorității modelelor. Mulți nu pot explica de ce scalarea ajută convergența.

52 Junior

Prin ce diferă o problemă de regresie de una de clasificare și ce funcții de cost folosești pentru fiecare?

Răspuns scurt: Regresia prezice o valoare numerică continuă, clasificarea o categorie. Pentru regresie folosești de obicei MSE, MAE sau Huber; pentru clasificare log loss (entropie încrucișată) sau hinge loss, iar evaluarea se face apoi cu metrici de business potrivite.

Diferența ține de tipul țintei:

  • Regresie: prețul unui apartament, durata unei livrări, cererea de mâine.
  • Clasificare: client care pleacă sau nu (binară), categoria unui tichet de suport (multiclasă), etichete multiple pe aceeași imagine (multi-label).

Funcția de cost (loss) este ce optimizează modelul la antrenare:

  • MSE (eroarea pătratică medie): penalizează puternic erorile mari; corespunde predicției mediei condiționate. Sensibilă la outlieri.
  • MAE (eroarea absolută medie): mai robustă; corespunde medianei condiționate.
  • Huber: pătratică pentru erori mici, liniară pentru erori mari, un compromis.
  • Quantile loss: când vrei să prezici o percentilă, de exemplu un stoc care acoperă cererea în 90% din zile.
  • Log loss: pentru clasificare probabilistică; penalizează sever o predicție greșită făcută cu încredere mare.
  • Hinge loss: folosit de SVM, urmărește marginea, nu probabilitatea.
PYTHON
from sklearn.metrics import mean_squared_error, mean_absolute_error, log_loss
print(mean_squared_error([3, 5, 10], [2.5, 5, 7]))    # 3.083
print(mean_absolute_error([3, 5, 10], [2.5, 5, 7]))   # 1.167
print(log_loss([1, 0, 1], [0.9, 0.1, 0.4]))           # 0.376

Regresia logistică este, în ciuda numelui, un model de clasificare. Iar unele probleme se pot formula în ambele feluri: „câte zile până la plată” (regresie) sau „plătește în 30 de zile, da sau nu” (clasificare). Alegerea depinde de decizia de business pe care o susține modelul.

Ce urmărește intervievatorul: Verifică vocabularul și legătura dintre loss și obiectiv. Greșeala tipică e să crezi că regresia logistică face regresie.

53 Mid

Cum validezi un model pe date de tip serie de timp sau pe date în care același client apare de mai multe ori?

Răspuns scurt: Pentru serii de timp antrenezi pe trecut și validezi pe perioade ulterioare (TimeSeriesSplit, eventual cu o pauză între ele). Pentru date grupate pui toate rândurile unui client în același fold (GroupKFold), ca modelul să fie testat pe clienți noi.

K-fold aleator presupune că rândurile sunt independente și provin din aceeași distribuție. Ambele ipoteze cad în aceste cazuri.

Serii de timp. Dacă amesteci aleator, modelul antrenează pe date din octombrie și e testat pe septembrie: vede viitorul. Scorul va fi optimist, mai ales dacă există tendințe sau sezonalitate.

PYTHON
from sklearn.model_selection import TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5, gap=7)   # gap: 7 rânduri între train și test
for tr, te in tscv.split(X):
    print(tr.min(), tr.max(), te.min(), te.max())

Fiecare fold antrenează pe tot ce e înainte și testează pe blocul următor (fereastră extinsă). Parametrul gap lasă o pauză, utilă când ținta se calculează pe o fereastră viitoare și ar putea suprapune perioadele. Datele trebuie sortate cronologic înainte.

Date grupate. Un pacient cu 20 de vizite sau un client cu 100 de tranzacții: dacă vizitele lui sunt și în train, și în test, modelul recunoaște clientul, nu învață tiparul general.

PYTHON
from sklearn.model_selection import GroupKFold, cross_val_score
# cross_val_score(model, X, y, groups=df["client_id"], cv=GroupKFold(n_splits=5))

Există și StratifiedGroupKFold, care păstrează și proporția claselor.

Regula generală: validarea trebuie să imite cum va fi folosit modelul. Dacă în producție prezici pentru săptămâna viitoare și pentru clienți noi, validarea trebuie să fie și temporală, și pe grupuri. Multe proiecte care „mergeau perfect” în notebook au eșuat exact aici.

Ce urmărește intervievatorul: Verifică dacă înțelegi că validarea trebuie să imite producția. Greșeala tipică e k-fold aleator pe date temporale.

54 Mid

Cum alegi hiperparametrii unui model? Ce este nested cross-validation?

Răspuns scurt: Cauți hiperparametrii optimizând un scor de validare încrucișată, cu grid search, random search sau optimizare bayesiană (de exemplu Optuna). Nested cross-validation pune această căutare într-o buclă interioară, iar o buclă exterioară estimează nepărtinitor performanța întregii proceduri.

Hiperparametrii (adâncimea arborelui, rata de învățare, regularizarea) nu se învață din date prin antrenare; îi alegi tu, comparând scorurile pe validare.

  • Grid search: încearcă toate combinațiile dintr-o grilă. Simplu, dar costul crește exponențial cu numărul de parametri.
  • Random search: eșantionează combinații aleatoare. La același buget e de obicei mai eficient, pentru că puțini hiperparametri contează cu adevărat și sunt explorați cu mai multe valori.
  • Optimizare bayesiană (Optuna, scikit-optimize): construiește un model al scorului în funcție de parametri și alege inteligent următoarea încercare. Poate opri devreme încercările slabe (pruning).
  • Successive halving (HalvingRandomSearchCV): elimină treptat candidații slabi pe bugete mici.
PYTHON
from scipy.stats import loguniform, randint
from sklearn.model_selection import RandomizedSearchCV, cross_val_score
from sklearn.ensemble import HistGradientBoostingClassifier

spatiu = {"learning_rate": loguniform(0.01, 0.3), "max_depth": randint(2, 10),
          "l2_regularization": loguniform(1e-4, 10)}
cautare = RandomizedSearchCV(HistGradientBoostingClassifier(), spatiu, n_iter=30,
                             cv=3, scoring="roc_auc", random_state=0)
# nested CV: cross_val_score(cautare, X, y, cv=5, scoring="roc_auc")

Problema: scorul cel mai bun din căutare este optimist, pentru că l-ai ales dintre multe încercări pe aceleași date. Nested cross-validation rezolvă asta: bucla exterioară (5 fold-uri) ține deoparte un fold, bucla interioară face căutarea pe restul. E costisitoare, deci se folosește când trebuie raportat un scor corect pe date puține; altfel, un set de test separat are același rol. Mai contează și să alegi scale logaritmice pentru parametri ca learning rate.

Ce urmărește intervievatorul: Verifică metoda de tuning și conștiința optimismului din selecție. Mulți raportează direct best_score_ ca performanță finală.

55 Mid

Scrie un pipeline scikit-learn care preprocesează diferit coloanele numerice și categoriale și antrenează un model.

Răspuns scurt: Folosești ColumnTransformer ca să aplici imputare și scalare pe coloanele numerice și imputare plus one-hot pe cele categoriale, apoi îl pui într-un Pipeline cu modelul. Tot obiectul se antrenează, se validează și se salvează ca o singură unitate.

PYTHON
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

df = pd.DataFrame({
    "varsta": [25, 40, None, 33, 51, 29, 45, 38],
    "venit": [3000, 7000, 4500, None, 9000, 3500, 6200, 5100],
    "oras": ["Cluj", "Iași", "Cluj", None, "Arad", "Iași", "Cluj", "Arad"],
    "abonament": ["lunar", "anual", "lunar", "anual", "anual", "lunar", "anual", "lunar"],
    "churn": [1, 0, 1, 0, 0, 1, 0, 1],
})
X, y = df.drop(columns="churn"), df["churn"]

numerice = ["varsta", "venit"]
categoriale = ["oras", "abonament"]

prep = ColumnTransformer([
    ("num", Pipeline([("imp", SimpleImputer(strategy="median")),
                      ("sc", StandardScaler())]), numerice),
    ("cat", Pipeline([("imp", SimpleImputer(strategy="most_frequent")),
                      ("ohe", OneHotEncoder(handle_unknown="ignore"))]), categoriale),
])

model = Pipeline([("prep", prep), ("clf", LogisticRegression(max_iter=1000))])
print(cross_val_score(model, X, y, cv=2).mean())
model.fit(X, y)
print(model.predict_proba(X.head(2))[:, 1])

De ce e important acest tipar:

  • La fiecare fold, imputarea, scalarea și codificarea se învață doar pe datele de antrenare, deci nu există leakage.
  • Hiperparametrii oricărui pas se pot căuta împreună, de exemplu clf__C sau prep__num__imp__strategy într-un GridSearchCV.
  • Obiectul salvat cu joblib conține toată logica de preprocesare, așa că în producție aplici exact aceleași transformări.
  • handle_unknown="ignore" evită erorile când apare o categorie nouă.

Ce urmărește intervievatorul: Exercițiu practic frecvent. Arată dacă scrii cod ML reproductibil și fără leakage, nu doar experimente în notebook.

56 Mid

Modelul tău are performanță slabă. Cum decizi dacă ai nevoie de mai multe date, de alte feature-uri sau de un model mai complex?

Răspuns scurt: Te uiți la curbele de învățare: dacă validarea încă urcă odată cu volumul de date, ajută mai multe date; erori mari și apropiate pe train și validare indică bias, deci feature-uri sau model mai bun.

O curbă de învățare arată scorul pe antrenare și pe validare în funcție de numărul de exemple de antrenare.

PYTHON
import numpy as np
from sklearn.model_selection import learning_curve
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)
dim, tr, val = learning_curve(RandomForestClassifier(random_state=0), X, y, cv=5,
                              train_sizes=np.linspace(0.1, 1.0, 5), scoring="roc_auc")
for n, a, b in zip(dim, tr.mean(axis=1), val.mean(axis=1)):
    print(n, round(a, 3), round(b, 3))

Interpretarea:

  • Ambele curbe joase și apropiate: bias mare. Mai multe date nu ajută. Ai nevoie de feature-uri mai informative, de un model mai flexibil sau de mai puțină regularizare.
  • Antrenare mult peste validare, iar validarea încă urcă: varianță mare. Mai multe date ajută; între timp, regularizare sau model mai simplu.
  • Curbele s-au aplatizat la un nivel nesatisfăcător: ai atins limita a ce pot spune aceste feature-uri. Merită verificată calitatea etichetelor; dacă etichetele sunt zgomotoase, plafonul e chiar acolo.

Înainte de toate acestea, verifici lucrurile simple: o comparație cu un baseline (predicția clasei majoritare, media, o regulă de business), erori de pipeline, leakage și dacă metrica aleasă reflectă problema. Analiza erorilor pe exemplele greșite (pe segmente, pe tipuri de cazuri) arată adesea concret ce feature lipsește, mai repede decât încercarea oarbă a unor modele mai mari.

Ce urmărește intervievatorul: Verifică metoda de diagnostic, nu ghicitul. Greșeala tipică e trecerea directă la un model mai complex fără să înțelegi cauza.

57 Senior

Un manager îți cere „un model care să reducă churn-ul”. Cum abordezi problema de la zero?

Răspuns scurt: Traduci cererea într-o decizie concretă (cine primește ce acțiune și când), definești ținta, orizontul și metrica de business, verifici datele disponibile și un baseline simplu, construiești iterativ și validezi impactul real printr-un experiment, nu doar prin AUC.

Un răspuns structurat pe etape:

  • Decizia susținută. Ce se va face cu predicția? De exemplu, echipa de retenție sună săptămânal 500 de clienți sau le oferă o reducere. Asta fixează capacitatea, momentul și costul acțiunii.
  • Definirea țintei. Ce înseamnă churn: anularea contractului, lipsa activității 60 de zile? Pe ce orizont: în următoarele 30 de zile? Momentul predicției contează pentru leakage.
  • Metrica. Tehnică (precision la primii 500, PR AUC) și de business (clienți păstrați, venit salvat minus costul ofertelor). Poate că mai util decât „cine pleacă” este „pe cine putem convinge să rămână”, adică un model de uplift, deoarece unii clienți ar pleca oricum, iar alții ar rămâne și fără ofertă.
  • Date și fezabilitate. Ce istoric există, cât de des se actualizează, ce e disponibil la momentul predicției, restricții de confidențialitate.
  • Baseline. O regulă simplă (clienți fără activitate de 30 de zile) sau o regresie logistică. Uneori baseline-ul rezolvă 80% din problemă.
  • Iterare. Feature-uri, model mai complex, analiză de erori, validare temporală.
  • Validarea impactului. Un A/B test: grupul contactat pe baza modelului comparat cu un grup de control, măsurând retenția reală.
  • Producție. Job programat, monitorizare, reantrenare, feedback de la echipa care folosește scorurile.

La nivel senior, întrebarea testează dacă știi să pui întrebări înainte să scrii cod și dacă ții modelul legat de valoarea pentru business.

Ce urmărește intervievatorul: Verifică gândirea de produs și framing-ul. Răspunsul slab începe cu alegerea algoritmului.

58 Senior

Ce înseamnă că un model este calibrat și cum îi calibrezi probabilitățile?

Răspuns scurt: Un model este calibrat dacă, dintre cazurile cărora le dă probabilitatea 0,7, aproximativ 70% sunt efectiv pozitive. Verifici cu o diagramă de fiabilitate și Brier score, iar calibrezi pe date separate cu regresie Platt (sigmoid) sau regresie izotonă.

Multe decizii folosesc probabilitatea propriu-zisă, nu doar ordinea: calculul profitului așteptat, combinarea cu un cost, comunicarea riscului. Un model poate avea AUC excelent și probabilități greșite.

Cauze tipice de necalibrare:

  • Random Forest tinde să evite extremele 0 și 1;
  • boosting-ul și rețelele pot fi prea încrezătoare;
  • ponderile pe clase, undersampling-ul sau SMOTE deplasează probabilitățile;
  • schimbarea prevalenței între antrenare și producție.

Verificare:

PYTHON
from sklearn.calibration import CalibratedClassifierCV, calibration_curve
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import brier_score_loss
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=6000, weights=[0.8], random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0, stratify=y)

rf = RandomForestClassifier(random_state=0).fit(X_tr, y_tr)
cal = CalibratedClassifierCV(RandomForestClassifier(random_state=0), method="isotonic", cv=5).fit(X_tr, y_tr)
for m in (rf, cal):
    p = m.predict_proba(X_te)[:, 1]
    print(round(brier_score_loss(y_te, p), 4))
frac_poz, medie_pred = calibration_curve(y_te, cal.predict_proba(X_te)[:, 1], n_bins=10)

Diagrama de fiabilitate plotează medie_pred față de frac_poz; un model calibrat stă pe diagonală.

Metode:

  • Platt (sigmoid): potrivește o regresie logistică pe scoruri; bun pentru date puține.
  • Izotonă: funcție monotonă arbitrară; mai flexibilă, dar cere mai multe date.

Calibrarea se face pe date care nu au fost folosite la antrenare, iar în producție se monitorizează, pentru că se degradează odată cu schimbarea distribuției.

Ce urmărește intervievatorul: Verifică nivelul senior: diferența dintre a ordona bine și a estima corect probabilități. Mulți consideră AUC-ul mare suficient.

Algoritmi și modele

59 Junior

Cum funcționează regresia liniară și care sunt ipotezele ei?

Răspuns scurt: Regresia liniară modelează ținta ca o combinație liniară de variabile plus o constantă și alege coeficienții care minimizează suma pătratelor erorilor. Ipotezele clasice: relație liniară, erori independente, varianță constantă a erorilor și, pentru inferență, erori aproximativ normale.

Modelul este y = b0 + b1·x1 + ... + bn·xn + eroare. Coeficienții se obțin prin metoda celor mai mici pătrate, fie analitic, fie prin gradient descent. Un coeficient bi arată cu cât se schimbă în medie y la o creștere cu o unitate a lui xi, cu celelalte variabile ținute constante.

PYTHON
import numpy as np
from sklearn.linear_model import LinearRegression
rng = np.random.default_rng(0)
suprafata = rng.uniform(40, 120, 200)
camere = rng.integers(1, 5, 200)
pret = 1500 * suprafata + 8000 * camere + rng.normal(0, 10000, 200)
X = np.column_stack([suprafata, camere])
m = LinearRegression().fit(X, pret)
print(m.coef_.round(0), round(m.intercept_))

Ipotezele și ce se întâmplă când nu sunt respectate:

  • Liniaritate: dacă relația e curbă, adaugi transformări (logaritm, termeni pătratici) sau alegi alt model.
  • Independența erorilor: încălcată la serii de timp (autocorelație); erorile standard devin prea mici.
  • Homoscedasticitate: dacă varianța erorilor crește cu valoarea prezisă, intervalele de încredere sunt greșite; ajută logaritmul țintei sau erorile standard robuste.
  • Normalitatea erorilor: contează pentru intervale și teste pe eșantioane mici, mai puțin pentru predicție.
  • Multicoliniaritate (variabile puternic corelate): coeficienții devin instabili și greu de interpretat; se verifică cu VIF și se tratează cu Ridge sau eliminând variabile.

Verificarea se face pe grafice de reziduuri. Pentru inferență detaliată (p-values pe coeficienți), statsmodels e mai potrivit decât scikit-learn.

Ce urmărește intervievatorul: Verifică fundamentul modelelor liniare. Se observă dacă știi să verifici ipotezele, nu doar să apelezi fit.

60 Junior

De ce regresia logistică este un model de clasificare și cum interpretezi coeficienții ei?

Răspuns scurt: Regresia logistică trece o combinație liniară prin funcția sigmoidă și obține o probabilitate între 0 și 1, apoi clasifică după un prag. Un coeficient arată schimbarea log-odds-urilor; exponențiala lui este raportul de șanse (odds ratio) pentru o creștere cu o unitate.

Modelul calculează z = b0 + b1·x1 + ... și apoi p = 1 / (1 + e^(-z)). Sigmoida comprimă orice număr real în intervalul (0, 1), deci p poate fi interpretat ca probabilitatea clasei pozitive. Se antrenează minimizând log loss.

Echivalent, log(p / (1 - p)) = z: modelul este liniar în log-odds. De aici interpretarea:

  • un coeficient de 0,7 pentru „număr de tichete de suport” înseamnă că fiecare tichet în plus crește log-odds-urile de churn cu 0,7;
  • e^0,7 ≈ 2,01, deci șansele (odds) de churn se dublează aproximativ pentru fiecare tichet în plus, la celelalte variabile constante.
PYTHON
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler

X, y = load_breast_cancer(return_X_y=True)
Xs = StandardScaler().fit_transform(X)
m = LogisticRegression(max_iter=1000).fit(Xs, y)
print(np.exp(m.coef_[0][:3]).round(2))   # odds ratio pe o deviație standard
print(m.predict_proba(Xs[:2])[:, 1].round(3))

Atenție la câteva lucruri:

  • Odds nu înseamnă probabilitate: dublarea șanselor de la 1% duce la aproximativ 2%, de la 50% duce la 67%.
  • În scikit-learn regularizarea L2 este activă implicit (C=1.0), deci coeficienții sunt micșorați.
  • Pe variabile scalate, coeficienții sunt comparabili între ei; pe variabile brute, nu.
  • Granița de decizie este liniară; relațiile neliniare cer feature-uri suplimentare.

Avantajele sale rămân importante în practică: e rapidă, stabilă, explicabilă și produce de obicei probabilități rezonabil calibrate.

Ce urmărește intervievatorul: Verifică înțelegerea unui model foarte folosit în industrie. Greșeala tipică e interpretarea coeficientului direct ca schimbare de probabilitate.

61 Junior

Cum alege un arbore de decizie unde să facă împărțirea? Ce sunt Gini și entropia?

Răspuns scurt: La fiecare nod, arborele încearcă toate variabilele și pragurile posibile și alege împărțirea care face nodurile-copil cât mai „pure”, adică reduce cel mai mult impuritatea Gini sau entropia (pentru regresie, varianța). Procesul se repetă recursiv până la un criteriu de oprire.

Pentru un nod cu proporțiile claselor p1, ..., pk:

  • Impuritatea Gini = 1 - Σ pi². E 0 pentru un nod pur și maximă când clasele sunt egale (0,5 la două clase).
  • Entropia = - Σ pi · log2(pi). E 0 pentru nod pur și 1 la două clase egale. Reducerea entropiei se numește câștig informațional.

Pentru fiecare împărțire candidat, se calculează media ponderată a impurității copiilor și se alege cea cu cea mai mare scădere. În practică Gini și entropia dau rezultate foarte asemănătoare; Gini e puțin mai rapid.

PYTHON
import numpy as np
def gini(y):
    _, c = np.unique(y, return_counts=True)
    p = c / c.sum()
    return 1 - np.sum(p ** 2)

parinte = np.array([1, 1, 1, 0, 0, 0])
stanga, dreapta = np.array([1, 1, 1, 0]), np.array([0, 0])
ponderat = (len(stanga) * gini(stanga) + len(dreapta) * gini(dreapta)) / len(parinte)
print(gini(parinte), round(ponderat, 3))   # 0.5 -> 0.25

Avantaje: interpretabil, nu cere scalare, captează interacțiuni și neliniarități. Dezavantaje: un arbore lăsat să crească până la capăt supraajustează și este instabil, mici schimbări în date pot produce un arbore complet diferit.

Controlul complexității: max_depth, min_samples_leaf, min_samples_split sau tăierea ulterioară prin ccp_alpha (cost-complexity pruning). Instabilitatea este motivul pentru care în practică se folosesc ansambluri de arbori: Random Forest și gradient boosting.

Ce urmărește intervievatorul: Verifică înțelegerea internă a celui mai folosit bloc din ansamblurile moderne. Mulți nu pot calcula un Gini simplu.

62 Junior

Cum funcționează Random Forest și de ce este de obicei mai bun decât un singur arbore?

Răspuns scurt: Random Forest antrenează mulți arbori, fiecare pe un eșantion bootstrap al datelor și cu un subset aleator de variabile la fiecare split, apoi mediază predicțiile. Medierea unor arbori puțin corelați reduce varianța fără să crească mult bias-ul.

Ingredientele:

  • Bagging (bootstrap aggregating): fiecare arbore vede un eșantion extras cu înlocuire, de aceeași mărime ca setul, deci aproximativ 63% din rânduri unice.
  • Aleatoriu pe variabile: la fiecare split se ia în calcul doar un subset de variabile (max_features, implicit √p pentru clasificare). Asta face arborii diferiți între ei; altfel toți ar folosi aceeași variabilă dominantă la rădăcină.
  • Agregare: vot majoritar sau media probabilităților pentru clasificare, media pentru regresie.

Un singur arbore adânc are bias mic și varianță mare. Media mai multor estimatori cu varianță mare și corelație mică are varianță mult mai mică. De aici rezultă robustețea.

PYTHON
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score

X, y = load_breast_cancer(return_X_y=True)
print(cross_val_score(DecisionTreeClassifier(random_state=0), X, y, cv=5).mean().round(3))
rf = RandomForestClassifier(n_estimators=300, oob_score=True, n_jobs=-1, random_state=0)
print(cross_val_score(rf, X, y, cv=5).mean().round(3))
print(rf.fit(X, y).oob_score_.round(3))

Scorul OOB (out-of-bag) folosește rândurile pe care fiecare arbore nu le-a văzut, ca o validare aproape gratuită.

Avantaje: puțin tuning, robust la outlieri, nu cere scalare, paralelizabil. Limite: modele mari și mai lente la predicție, nu extrapolează în afara intervalului văzut la antrenare, iar pe date tabelare gradient boosting bine reglat obține deseori scoruri mai bune.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce funcționează ansamblurile. Greșeala tipică e să spui doar „mulți arbori votează” fără rolul aleatorului pe variabile.

63 Junior

Cum funcționează algoritmul k-means și cum alegi numărul de clustere?

Răspuns scurt: K-means alege k centre, atribuie fiecare punct celui mai apropiat centru, recalculează centrele ca media punctelor atribuite și repetă până la stabilizare. K se alege combinând metoda cotului, scorul siluetă și, mai ales, utilitatea segmentelor pentru business.

Pașii algoritmului:

  • inițializezi k centre (scikit-learn folosește implicit k-means++, care le alege depărtate între ele);
  • atribui fiecare punct centrului cel mai apropiat (distanță euclidiană);
  • muți fiecare centru în media punctelor sale;
  • repeți ultimii doi pași până când atribuirile nu se mai schimbă.

Algoritmul minimizează suma pătratelor distanțelor față de centre (inerția). Converge la un minim local, de aceea se rulează de mai multe ori cu inițializări diferite (n_init).

PYTHON
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_blobs

X, _ = make_blobs(n_samples=600, centers=4, random_state=7)
Xs = StandardScaler().fit_transform(X)
for k in range(2, 8):
    km = KMeans(n_clusters=k, n_init=10, random_state=0).fit(Xs)
    print(k, round(km.inertia_, 1), round(silhouette_score(Xs, km.labels_), 3))

Alegerea lui k:

  • Metoda cotului: inerția scade mereu cu k; cauți punctul de unde scăderea devine mică.
  • Scorul siluetă: compară distanța medie față de propriul cluster cu distanța față de cel mai apropiat cluster vecin; valori mai mari sunt mai bune.
  • Criteriul de business: cinci segmente pe care echipa de marketing le poate diferenția valorează mai mult decât unsprezece optime matematic.

Limite: cere scalarea datelor, presupune clustere aproximativ sferice și de mărimi similare, e sensibil la outlieri și lucrează doar cu variabile numerice. Pentru forme arbitrare există DBSCAN, pentru date mixte k-prototypes, iar pentru apartenențe probabilistice modele de amestec gaussian.

Ce urmărește intervievatorul: Verifică înțelegerea celui mai folosit algoritm de clustering. Mulți uită scalarea și tratează metoda cotului ca pe un răspuns precis.

64 Junior

Cum funcționează k-nearest neighbors (KNN) și care sunt dezavantajele lui?

Răspuns scurt: KNN nu învață parametri: pentru un punct nou caută cele mai apropiate k exemple din antrenare și prezice clasa majoritară (sau media lor pentru regresie). Este simplu, dar lent la predicție pe date mari, sensibil la scalare și slab în dimensiuni mari.

KNN este un model „leneș” (lazy learning): la antrenare doar stochează datele. Toată munca se face la predicție:

  • calculezi distanța de la punctul nou la toate exemplele (de obicei euclidiană);
  • iei cele mai apropiate k;
  • pentru clasificare votezi, pentru regresie faci media; opțional ponderezi după inversul distanței (weights="distance").
PYTHON
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
pipe = make_pipeline(StandardScaler(), KNeighborsClassifier())
grid = GridSearchCV(pipe, {"kneighborsclassifier__n_neighbors": [1, 3, 5, 11, 21]}, cv=5)
print(grid.fit(X, y).best_params_)

Alegerea lui k reflectă compromisul bias-variance: k mic urmărește zgomotul, k mare netezește excesiv. Pentru clasificare binară se preferă k impar, ca să eviți egalitățile.

Dezavantaje:

  • Scalare obligatorie: altfel variabila cu valori mari domină distanța.
  • Cost la predicție: naiv O(n) per interogare; structuri ca KD-tree sau Ball tree ajută în dimensiuni mici, iar la scară mare se folosesc căutări aproximative (de exemplu FAISS).
  • Blestemul dimensionalității: în zeci sau sute de dimensiuni distanțele devin asemănătoare.
  • Sensibil la variabile irelevante și la clase dezechilibrate.

Ideea de „cei mai apropiați vecini” rămâne foarte actuală: căutarea semantică și sistemele RAG găsesc documentele cele mai apropiate pe baza embeddings-urilor, adică exact o căutare de vecini.

Ce urmărește intervievatorul: Verifică înțelegerea unui algoritm simplu și a limitelor lui. Răspunsul bun leagă KNN de căutarea pe embeddings.

65 Junior

Ce este o rețea neuronală și cum învață?

Răspuns scurt: O rețea neuronală este o succesiune de straturi de neuroni; fiecare neuron calculează o sumă ponderată a intrărilor și aplică o funcție de activare neliniară. Învață prin backpropagation: calculează gradientul erorii față de fiecare pondere și o ajustează cu gradient descent.

Un neuron face z = w·x + b și apoi a = f(z), unde f este o funcție de activare (ReLU, sigmoid). Un strat are mulți neuroni, iar o rețea are straturi succesive: intrare, unul sau mai multe straturi ascunse, ieșire. Neliniaritatea este esențială: fără ea, oricâte straturi ai pune, rețeaua rămâne echivalentă cu un model liniar.

Antrenarea, la fiecare lot de date:

  • Forward pass: calculezi predicțiile strat cu strat.
  • Loss: compari predicțiile cu ținta (MSE, entropie încrucișată).
  • Backpropagation: aplici regula lanțului de la ieșire spre intrare și obții gradientul loss-ului față de fiecare pondere.
  • Actualizare: un optimizator (SGD, Adam) modifică ponderile în direcția care reduce loss-ul.
PYTHON
import torch
from torch import nn

X = torch.randn(512, 10)
y = (X[:, 0] + X[:, 1] > 0).float().unsqueeze(1)

model = nn.Sequential(nn.Linear(10, 32), nn.ReLU(), nn.Linear(32, 1))
optim = torch.optim.Adam(model.parameters(), lr=0.01)
loss_fn = nn.BCEWithLogitsLoss()

for epoca in range(200):
    optim.zero_grad()
    loss = loss_fn(model(X), y)
    loss.backward()        # backpropagation
    optim.step()           # actualizarea ponderilor
print(round(loss.item(), 4))

Pentru date tabelare clasice, gradient boosting este de obicei mai bun și mai ieftin. Rețelele câștigă pe date nestructurate: imagini (rețele convoluționale), text și audio (transformere), unde învață singure reprezentările. În scikit-learn există și MLPClassifier, suficient pentru experimente mici.

Ce urmărește intervievatorul: Verifică înțelegerea de bază a deep learning. Greșeala tipică: nu poți explica de ce activările neliniare sunt necesare.

66 Mid

Prin ce diferă gradient boosting (XGBoost, LightGBM) de Random Forest?

Răspuns scurt: Random Forest construiește arbori adânci independent și îi mediază, reducând varianța. Gradient boosting construiește arbori mici secvențial, fiecare corectând erorile ansamblului de până atunci, reducând bias-ul. Boosting-ul obține des scoruri mai bune pe date tabelare, dar cere mai mult tuning.

Random Forest (bagging): arbori adânci, antrenați în paralel pe eșantioane bootstrap, cu predicție mediată. Puțin sensibil la hiperparametri, greu de supraajustat prin adăugarea de arbori.

Gradient boosting: pornește de la o predicție simplă (de exemplu media) și adaugă pe rând arbori mici. Fiecare arbore nou aproximează gradientul negativ al loss-ului față de predicțiile curente; pentru MSE, asta înseamnă chiar reziduurile. Contribuția fiecărui arbore se înmulțește cu un learning rate mic.

PYTHON
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import lightgbm as lgb

X, y = load_breast_cancer(return_X_y=True)
X_tr, X_val, y_tr, y_val = train_test_split(X, y, random_state=0, stratify=y)
m = lgb.LGBMClassifier(n_estimators=2000, learning_rate=0.03, num_leaves=15, verbose=-1)
m.fit(X_tr, y_tr, eval_set=[(X_val, y_val)], callbacks=[lgb.early_stopping(100)])
print(m.best_iteration_)

Diferențe practice:

  • Boosting-ul poate supraajusta dacă adaugi prea mulți arbori; se folosește early stopping pe un set de validare.
  • Hiperparametri importanți: learning rate, numărul de arbori, adâncimea sau num_leaves, min_child_samples, subeșantionare pe rânduri și coloane, regularizare L1 și L2.
  • XGBoost, LightGBM și CatBoost sunt implementări optimizate: histograme pentru split-uri rapide, tratarea nativă a valorilor lipsă, iar CatBoost și LightGBM au suport special pentru categoriale. În scikit-learn există HistGradientBoostingClassifier.
  • Antrenarea e secvențială pe arbori, dar paralelizată în interiorul fiecărui arbore.

Pe date tabelare, gradient boosting bine reglat este un punct de plecare foarte puternic, iar Random Forest rămâne un baseline robust care merge bine din prima.

Ce urmărește intervievatorul: Verifică dacă înțelegi cele două filozofii de ansamblu. Greșeala tipică e să nu știi că boosting-ul cere early stopping.

67 Mid

Cum explici predicțiile unui model complex? Ce este SHAP și care sunt limitele importanței feature-urilor?

Răspuns scurt: Folosești importanță globală (prin permutare) și explicații locale, pe fiecare predicție, cu SHAP, care împarte predicția în contribuții aditive ale fiecărei variabile pe baza valorilor Shapley. Explicațiile descriu modelul, nu cauzalitatea din lumea reală.

Nivele de explicabilitate:

  • Globală: ce variabile contează în general. Importanța pe bază de impuritate din arbori e rapidă, dar favorizează variabilele cu multe valori și se calculează pe antrenare. Importanța prin permutare pe date de validare e mai de încredere.
  • Efectul unei variabile: grafice de dependență parțială (PDP) și ICE arată cum se schimbă predicția când variezi o variabilă.
  • Locală: de ce clientul X a primit scorul 0,82.

SHAP atribuie fiecărei variabile o contribuție astfel încât valoarea de bază (predicția medie) plus suma contribuțiilor să dea exact predicția. Se bazează pe valorile Shapley din teoria jocurilor, adică media contribuției marginale a variabilei în toate coalițiile posibile. Pentru arbori există TreeExplainer, exact și rapid.

PYTHON
import shap
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import fetch_california_housing

X, y = fetch_california_housing(return_X_y=True, as_frame=True)
m = RandomForestRegressor(n_estimators=100, random_state=0).fit(X[:3000], y[:3000])
expl = shap.TreeExplainer(m)
sv = expl(X[:200])
# shap.plots.beeswarm(sv)      rezumat global
# shap.plots.waterfall(sv[0])  explicația unei predicții

Limite importante:

  • Variabilele corelate își împart sau își fură importanța, iar valorile pot crea combinații nerealiste.
  • Explicațiile spun ce a folosit modelul, nu ce cauzează rezultatul. „Venitul crește scorul” nu înseamnă că mărirea venitului ar schimba comportamentul.
  • Pentru modele care nu sunt arbori, estimările sunt aproximative și costisitoare.

Când explicabilitatea este o cerință legală (de exemplu decizii de creditare), un model simplu și interpretabil poate fi alegerea mai bună.

Ce urmărește intervievatorul: Verifică dacă știi să comunici și să auditezi un model. Greșeala tipică e prezentarea SHAP ca efect cauzal.

68 Mid

Cum funcționează un SVM și ce este kernel trick-ul?

Răspuns scurt: Un SVM caută hiperplanul care separă clasele cu marginea maximă, adică cel mai departe de punctele cele mai apropiate (vectorii suport). Kernel trick-ul calculează produse scalare într-un spațiu de dimensiune mai mare fără să-l construiască explicit, permițând granițe neliniare.

Pentru două clase separabile există infinit de multe drepte (hiperplane) care le despart. SVM alege dreapta care maximizează distanța până la cele mai apropiate puncte din fiecare clasă. Acele puncte sunt vectorii suport și numai ele determină soluția.

Datele reale nu sunt perfect separabile, așa că se folosește marginea soft: se permit unele încălcări, penalizate prin parametrul C. Un C mare penalizează puternic erorile (margine îngustă, risc de overfitting), un C mic tolerează erori (margine largă, model mai simplu).

Kernel trick: algoritmul depinde doar de produsele scalare dintre puncte. Înlocuind produsul scalar cu o funcție kernel, de exemplu RBF: K(x, y) = exp(-γ · ||x - y||²), lucrezi implicit într-un spațiu în care datele devin separabile liniar, fără să calculezi coordonatele acolo.

PYTHON
from sklearn.datasets import make_moons
from sklearn.svm import SVC
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score

X, y = make_moons(n_samples=500, noise=0.2, random_state=0)
for kernel in ["linear", "rbf"]:
    m = make_pipeline(StandardScaler(), SVC(kernel=kernel, C=1.0, gamma="scale"))
    print(kernel, cross_val_score(m, X, y, cv=5).mean().round(3))

Pe datele în formă de semilune, kernel-ul RBF bate clar varianta liniară. gamma controlează cât de locală e influența fiecărui punct.

Practic: SVM cere scalare, are complexitate între pătratică și cubică în numărul de exemple (lent peste câteva zeci de mii de rânduri) și nu produce nativ probabilități (probability=True adaugă o calibrare internă costisitoare). Pe date mari, LinearSVC sau gradient boosting sunt mai practice.

Ce urmărește intervievatorul: Verifică înțelegerea unui model clasic întrebat des la interviuri. Mulți nu știu rolul lui C și gamma.

69 Mid

De ce ReLU a înlocuit sigmoida în straturile ascunse? Ce este problema gradientului care dispare?

Răspuns scurt: Sigmoida are derivata cel mult 0,25 și aproape zero la valori mari, așa că gradientul se micșorează exponențial prin straturi și primele straturi aproape nu învață. ReLU are derivata 1 pentru valori pozitive, e ieftină de calculat și permite antrenarea rețelelor adânci.

La backpropagation, gradientul unui strat timpuriu este produsul derivatelor tuturor straturilor de după el. Derivata sigmoidei, σ(z)·(1 - σ(z)), este maximum 0,25 și tinde la zero când z este mare în valoare absolută (neuronul e „saturat”). Înmulțind multe astfel de valori mici, gradientul devine practic zero: vanishing gradient. Problema inversă, exploding gradient, apare când produsele cresc necontrolat, frecvent în rețele recurente.

ReLU, f(z) = max(0, z), are derivata 1 pentru z > 0, deci gradientul trece nealterat prin neuronii activi. E și foarte ieftină de calculat.

PYTHON
import numpy as np
z = np.array([-5.0, -1.0, 0.5, 5.0])
sig = 1 / (1 + np.exp(-z))
print((sig * (1 - sig)).round(4))   # [0.0066 0.1966 0.235 0.0066]
print((z > 0).astype(float))        # derivata ReLU: [0. 0. 1. 1.]

ReLU are propria problemă: neuronii care ajung să primească doar intrări negative au gradient zero și „mor”. Variante: Leaky ReLU, ELU, iar în transformere se folosesc GELU sau SiLU.

Alte tehnici care rezolvă gradientul care dispare sau explodează:

  • inițializarea ponderilor potrivită activării (He pentru ReLU, Xavier/Glorot pentru tanh);
  • normalizare (BatchNorm, LayerNorm);
  • conexiuni reziduale (ResNet, transformere), care oferă gradientului un drum direct;
  • gradient clipping pentru explozii;
  • LSTM și GRU pentru secvențe.

Sigmoida rămâne potrivită pe stratul de ieșire pentru clasificare binară, unde vrei o probabilitate.

Ce urmărește intervievatorul: Verifică înțelegerea mecanică a rețelelor adânci. Greșeala tipică e să spui „ReLU e mai bună” fără să explici de ce.

70 Mid

Ce tehnici folosești ca o rețea neuronală să nu supraajusteze?

Răspuns scurt: Mai multe date sau augmentare, early stopping pe validare, regularizare L2 (weight decay), dropout, o arhitectură mai mică și transfer learning de la un model pre-antrenat. Batch normalization ajută în principal stabilitatea antrenării, cu un efect regularizator secundar.

Rețelele au foarte mulți parametri și pot memora setul de antrenare. Semnalul clasic: loss-ul de antrenare scade continuu, iar cel de validare începe să crească.

  • Early stopping: monitorizezi loss-ul pe validare și oprești antrenarea (păstrând ponderile cele mai bune) după câteva epoci fără îmbunătățire. Simplu și foarte eficient.
  • Weight decay (L2): penalizează ponderile mari. În PyTorch se folosește des AdamW, care aplică corect weight decay separat de pasul adaptiv.
  • Dropout: la antrenare, fiecare neuron e dezactivat cu probabilitatea p, deci rețeaua nu se poate baza pe neuroni anume. La evaluare dropout-ul se oprește (model.eval() în PyTorch); uitarea acestui apel e o greșeală frecventă.
  • Augmentarea datelor: pentru imagini, rotații, decupări, schimbări de luminozitate; pentru text, parafrazări. Creează exemple noi plauzibile.
  • Model mai mic sau mai puține epoci.
  • Transfer learning: pornești de la un model pre-antrenat pe date mari și ajustezi doar ultimele straturi.
PYTHON
import torch
from torch import nn
model = nn.Sequential(
    nn.Linear(100, 256), nn.ReLU(), nn.Dropout(0.3),
    nn.Linear(256, 64), nn.ReLU(), nn.Dropout(0.3),
    nn.Linear(64, 1),
)
optim = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-2)
# model.train() la antrenare, model.eval() înainte de validare și predicție

Batch normalization normalizează activările pe fiecare lot, permițând learning rate-uri mai mari și o antrenare mai stabilă; zgomotul dintre loturi are și un ușor efect de regularizare. Ca și dropout, se comportă diferit în modul de antrenare față de cel de evaluare.

Ce urmărește intervievatorul: Verifică experiența practică de antrenare a rețelelor. Greșeala tipică e să uiți de model.eval() la evaluare.

71 Mid

Când ai folosi DBSCAN în loc de k-means și cum evaluezi un clustering fără etichete?

Răspuns scurt: DBSCAN grupează punctele după densitate, găsește clustere de forme arbitrare, nu cere numărul de clustere și marchează punctele izolate ca zgomot. Evaluezi cu metrici interne (siluetă, Davies-Bouldin), cu stabilitatea rezultatelor și, mai ales, cu interpretarea și utilitatea segmentelor.

DBSCAN are doi parametri: eps (raza vecinătății) și min_samples. Un punct cu cel puțin min_samples vecini în raza eps este punct central; clusterele se formează prin conectarea punctelor centrale apropiate, iar punctele neatinse de niciun cluster primesc eticheta -1 (zgomot).

Îl alegi în locul lui k-means când:

  • clusterele au forme neregulate (inele, benzi, zone geografice);
  • există outlieri pe care nu vrei să-i forțezi într-un grup;
  • nu știi numărul de grupuri.

Limite: o singură valoare eps funcționează prost când clusterele au densități foarte diferite (HDBSCAN, inclus în scikit-learn din 1.3, rezolvă parțial asta), iar în dimensiuni mari distanțele își pierd sensul.

PYTHON
from sklearn.cluster import DBSCAN, KMeans
from sklearn.datasets import make_moons
from sklearn.metrics import silhouette_score, davies_bouldin_score

X, _ = make_moons(n_samples=400, noise=0.06, random_state=0)
db = DBSCAN(eps=0.2, min_samples=5).fit(X)
km = KMeans(n_clusters=2, n_init=10, random_state=0).fit(X)
print(set(db.labels_))                     # două clustere și eventual -1
print(round(davies_bouldin_score(X, km.labels_), 3))

Evaluarea fără etichete:

  • Siluetă și Davies-Bouldin: utile pentru comparații, dar favorizează clusterele compacte și sferice, deci pot penaliza tocmai rezultatul bun al DBSCAN pe forme neregulate.
  • Stabilitate: rulezi pe subeșantioane sau cu parametri ușor diferiți și verifici dacă grupurile rămân similare (de exemplu cu adjusted Rand index între rulări).
  • Interpretare: profilul fiecărui cluster pe variabile cheie și dacă duce la acțiuni diferite.
  • Dacă ai câteva etichete externe, le folosești ca validare.

Ce urmărește intervievatorul: Verifică dacă știi alternative la k-means și cum validezi rezultate nesupervizate. Mulți se bazează orbește pe scorul siluetă.

72 Senior

Ce sunt embeddings și transfer learning? Cum ai construi un clasificator de texte în română cu puține date etichetate?

Răspuns scurt: Embeddings sunt vectori denși care plasează obiecte similare aproape unele de altele; transfer learning refolosește un model pre-antrenat. Cu puține etichete, antrenezi un clasificator simplu peste embeddings dintr-un model multilingv, apoi faci fine-tuning dacă datele permit.

Un embedding transformă un obiect discret într-un vector, de exemplu de 384 sau 768 de dimensiuni, astfel încât distanța dintre vectori să reflecte similaritatea de sens. Embeddings se învață ca efect secundar al unei sarcini (prezicerea cuvintelor, a contextului) și pot fi apoi refolosite.

Transfer learning: un model antrenat pe volume mari a învățat reprezentări generale. Le refolosești pentru sarcina ta, unde ai doar câteva sute de exemple.

Plan pentru clasificarea tichetelor de suport în română, de la ieftin la scump:

  • Baseline: TF-IDF plus regresie logistică. Rapid și surprinzător de bun.
  • Embeddings înghețate: un model de sentence embeddings multilingv care acoperă și româna, apoi regresie logistică peste vectori.
PYTHON
from sentence_transformers import SentenceTransformer
from sklearn.linear_model import LogisticRegression

texte = ["Nu pot să mă autentific", "Vreau factura pe luna trecută", "Parola nu merge"]
etichete = ["cont", "facturare", "cont"]
enc = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")
X = enc.encode(texte)
clf = LogisticRegression(max_iter=1000).fit(X, etichete)
print(clf.predict(enc.encode(["Am uitat parola"])))
  • Fine-tuning al unui transformer (de exemplu un model BERT multilingv sau unul pre-antrenat pe română) pe datele tale, dacă ai câteva mii de exemple și resurse GPU.
  • LLM cu instrucțiuni (zero-shot sau few-shot) pentru prototip sau pentru a genera etichete inițiale, care apoi se verifică manual.

Decizia senior ține cont de cost per predicție, latență, confidențialitatea datelor (unde rulează modelul) și de faptul că un set de test etichetat atent rămâne obligatoriu indiferent de abordare.

Ce urmărește intervievatorul: Verifică familiaritatea cu NLP modern și judecata de cost-beneficiu. Greșeala tipică e să sari direct la fine-tuning sau la un LLM scump fără baseline.

Metrici de evaluare și A/B testing

73 Junior

Ce este matricea de confuzie și cum calculezi precision și recall din ea?

Răspuns scurt: Matricea de confuzie numără adevărații pozitivi, falșii pozitivi, adevărații negativi și falșii negativi. Precision = TP / (TP + FP), adică cât de des are dreptate modelul când spune „pozitiv”; recall = TP / (TP + FN), adică ce parte din pozitivii reali găsește.

Pentru clasificare binară, cu „pozitiv” = fraudă:

  • TP (true positive): fraude marcate ca fraude;
  • FP (false positive): tranzacții normale marcate ca fraude;
  • FN (false negative): fraude ratate;
  • TN (true negative): tranzacții normale marcate corect.
PYTHON
from sklearn.metrics import confusion_matrix, precision_score, recall_score, classification_report
y_real = [1, 1, 1, 1, 0, 0, 0, 0, 0, 0]
y_pred = [1, 1, 1, 0, 1, 1, 0, 0, 0, 0]
print(confusion_matrix(y_real, y_pred))   # [[TN FP] [FN TP]] = [[4 2] [1 3]]
print(precision_score(y_real, y_pred))    # 3 / (3 + 2) = 0.6
print(recall_score(y_real, y_pred))       # 3 / (3 + 1) = 0.75
print(classification_report(y_real, y_pred))

Atenție la convenția din scikit-learn: rândurile sunt clasa reală, coloanele clasa prezisă, iar clasa 0 este prima.

Când contează fiecare:

  • Precision ridicată când un fals pozitiv costă mult: filtrul de spam care ascunde un e-mail important, o alertă care trimite un om pe teren.
  • Recall ridicat când un fals negativ costă mult: detecția unei boli grave, a fraudei, a unui defect de siguranță.

Cele două sunt în tensiune: coborând pragul de decizie, modelul marchează mai multe cazuri ca pozitive, deci recall-ul crește și precision-ul scade de obicei. Alte metrici derivate: specificitatea TN / (TN + FP) și rata de fals pozitivi FP / (FP + TN). Pentru mai multe clase, matricea devine k x k și metricile se mediază (macro, micro, ponderat).

Ce urmărește intervievatorul: Întrebare de bază garantată. Se verifică dacă știi formulele și, mai ales, când contează fiecare metrică.

74 Junior

De ce acuratețea poate fi o metrică înșelătoare și ce este scorul F1?

Răspuns scurt: Pe clase dezechilibrate, un model care prezice mereu clasa majoritară are acuratețe mare și nu e util. F1 este media armonică dintre precision și recall, deci e mare doar când ambele sunt bune, și se raportează pe clasa de interes.

Acuratețea este (TP + TN) / total. Dacă 98% din pacienți sunt sănătoși, un „model” care spune mereu „sănătos” are 98% acuratețe și zero utilitate: recall 0 pe clasa bolnavă.

PYTHON
from sklearn.metrics import accuracy_score, f1_score
y = [0] * 98 + [1] * 2
pred_naiv = [0] * 100
print(accuracy_score(y, pred_naiv))              # 0.98
print(f1_score(y, pred_naiv, zero_division=0))   # 0.0

F1 = 2 · P · R / (P + R). Media armonică pedepsește dezechilibrul: cu precision 1,0 și recall 0,1, media aritmetică ar fi 0,55, dar F1 este doar 0,18. Un model trebuie să fie bun la ambele ca să aibă F1 mare.

Variante:

  • F-beta: β > 1 dă mai multă greutate recall-ului (F2 pentru screening medical), β < 1 precision-ului.
  • Macro F1: media F1 pe clase, fiecare clasă contează egal; util când clasele rare sunt importante.
  • Micro F1: calculat pe totalul TP, FP, FN; la clasificare cu o singură etichetă pe exemplu este egal cu acuratețea.
  • Weighted F1: ponderat după numărul de exemple pe clasă.

Limita F1: depinde de un prag fix și ignoră adevărații negativi. Dacă cele două tipuri de eroare au costuri cunoscute, o funcție de cost explicită este mai bună. Iar o comparație cu un baseline (clasa majoritară, o regulă simplă) arată imediat dacă un scor aparent bun înseamnă ceva.

Ce urmărește intervievatorul: Verifică dacă alegi metrica după problemă. Greșeala tipică e raportarea acurateței pe date dezechilibrate.

75 Junior

Ce reprezintă curba ROC și aria de sub ea (AUC)?

Răspuns scurt: Curba ROC arată rata de adevărați pozitivi față de rata de fals pozitivi pentru toate pragurile de decizie. AUC rezumă curba într-un număr: probabilitatea ca un exemplu pozitiv ales aleator să primească un scor mai mare decât unul negativ ales aleator.

Un clasificator probabilistic produce scoruri; clasa depinde de prag. Pentru fiecare prag calculezi:

  • TPR (recall) = TP / (TP + FN);
  • FPR = FP / (FP + TN).

Curba ROC unește punctele (FPR, TPR) de la pragul maxim (0, 0) la pragul minim (1, 1). Un model aleator stă pe diagonală, cu AUC = 0,5; un model perfect urcă direct la (0, 1), cu AUC = 1.

PYTHON
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score, roc_curve

X, y = make_classification(n_samples=2000, random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
p = LogisticRegression(max_iter=1000).fit(X_tr, y_tr).predict_proba(X_te)[:, 1]
print(round(roc_auc_score(y_te, p), 3))
fpr, tpr, praguri = roc_curve(y_te, p)

Avantaje: nu depinde de un prag anume și nici de calibrare, ci doar de ordinea scorurilor. Interpretarea ca probabilitate de ordonare corectă a unei perechi o face ușor de explicat.

Limite:

  • Pe date foarte dezechilibrate, FPR rămâne mică chiar și cu mulți falși pozitivi în valoare absolută, deci ROC AUC poate părea excelent în timp ce precision-ul e slab. Acolo PR AUC este mai informativ.
  • Rezumă toate pragurile, inclusiv cele pe care nu le vei folosi niciodată.
  • Nu spune nimic despre calibrarea probabilităților.

Un AUC sub 0,5 indică de obicei o inversare a etichetelor sau a semnului scorului.

Ce urmărește intervievatorul: Întrebare foarte frecventă. Răspunsul bun include interpretarea probabilistică și limita pe date dezechilibrate.

76 Junior

Ce metrici folosești pentru un model de regresie? Compară MAE, RMSE, R² și MAPE.

Răspuns scurt: MAE este eroarea absolută medie, ușor de explicat și robustă; RMSE penalizează mai mult erorile mari; R² arată ce parte din varianța țintei explică modelul; MAPE dă eroarea în procente, dar explodează când valorile reale sunt aproape de zero.

PYTHON
import numpy as np
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score, mean_absolute_percentage_error
y = np.array([100, 150, 200, 250, 1000])
p = np.array([110, 140, 210, 240, 700])
print(mean_absolute_error(y, p))                # 68.0
print(np.sqrt(mean_squared_error(y, p)))        # 134.6
print(round(r2_score(y, p), 3))
print(round(mean_absolute_percentage_error(y, p), 3))
  • MAE: „în medie greșim cu 68 de unități”. Aceeași unitate ca ținta, ușor de comunicat. Toate erorile contează liniar.
  • RMSE: rădăcina erorii pătratice medii. Aici e de două ori mai mare decât MAE din cauza singurei erori de 300. Alegi RMSE când erorile mari sunt disproporționat de costisitoare.
  • R²: 1 - (eroarea modelului / eroarea predicției cu media). 1 este perfect, 0 înseamnă că modelul nu e mai bun decât media, iar valorile negative înseamnă că e mai slab. Nu are unitate, deci e comod pentru comparații, dar nu spune cât de mari sunt erorile în termeni de business.
  • MAPE: media erorilor relative. Intuitiv pentru manageri („greșim cu 8%”), dar nedefinit la valori reale zero și asimetric: penalizează mai mult supra-estimările decât sub-estimările de aceeași mărime relativă. Alternative: WAPE (suma erorilor absolute împărțită la suma valorilor reale) sau sMAPE.

Alegerea metricii trebuie să urmeze costul real: la prognoza stocurilor, o sub-estimare (rupere de stoc) poate costa mai mult decât o supra-estimare, caz în care merită o metrică asimetrică sau quantile loss. Raportezi întotdeauna și față de un baseline, de exemplu valoarea de săptămâna trecută.

Ce urmărește intervievatorul: Verifică alegerea metricii după context. Mulți folosesc MAPE pe date cu zerouri sau raportează R² fără unitate de business.

77 Mid

Când preferi curba precision-recall în locul curbei ROC și cum alegi pragul de decizie?

Răspuns scurt: Preferi curba precision-recall când clasa pozitivă e rară și te interesează calitatea predicțiilor pozitive. Pragul îl alegi pe date de validare, după costul erorilor, după capacitatea de acțiune (de exemplu primii 500 de clienți) sau după o constrângere de recall ori precision minim.

Pe date cu 0,5% fraudă, ROC folosește FPR, al cărei numitor este numărul uriaș de negativi. Un model care marchează 1.000 de tranzacții normale ca suspecte are o FPR mică și o curbă ROC frumoasă, deși analiștii ar verifica de zeci de ori mai multe alarme false decât fraude. Curba precision-recall nu folosește adevărații negativi și arată direct acest cost. Un clasificator aleator are PR AUC egal cu prevalența (0,005 aici), nu 0,5, așa că scorul trebuie comparat cu acest nivel de bază.

Alegerea pragului nu e o problemă de ML, ci de decizie:

  • Cost explicit: dacă o fraudă ratată costă 500 de lei și o verificare manuală 5 lei, alegi pragul care minimizează costul total pe validare.
  • Capacitate: echipa poate verifica 200 de cazuri pe zi, deci iei primele 200 de scoruri; metrica relevantă devine precision@200.
  • Constrângere: „recall cel puțin 90%”, apoi maximizezi precision-ul.
PYTHON
import numpy as np
from sklearn.metrics import precision_recall_curve

def prag_cost_minim(y_val, p_val, cost_fn=500, cost_fp=5):
    praguri = np.unique(p_val)
    costuri = [cost_fn * np.sum((p_val < t) & (y_val == 1)) +
               cost_fp * np.sum((p_val >= t) & (y_val == 0)) for t in praguri]
    return praguri[int(np.argmin(costuri))]

# prec, rec, thr = precision_recall_curve(y_val, p_val)

Din scikit-learn 1.5 există TunedThresholdClassifierCV, care optimizează pragul prin validare încrucișată după o metrică aleasă. Pragul se stabilește pe validare, nu pe test, și se revizuiește când prevalența se schimbă în producție.

Ce urmărește intervievatorul: Verifică legătura dintre metrici și decizii reale. Greșeala tipică e folosirea pragului 0,5 implicit pe date dezechilibrate.

78 Mid

Cum proiectezi un A/B test pentru o schimbare pe pagina de checkout?

Răspuns scurt: Formulezi ipoteza și metrica principală, alegi unitatea de randomizare (utilizatorul), stabilești dinainte mărimea minimă a efectului, α și puterea, calculezi eșantionul și durata (cel puțin cicluri săptămânale complete), definești metrici de protecție și analizezi o singură dată, la final.

Pași:

  • Ipoteza: „Afișarea costului de livrare mai devreme crește rata de finalizare a comenzii.”
  • Metrica principală: rata de conversie per utilizator expus. Una singură, decisă înainte. Guardrails: valoarea medie a comenzii, rata de retur, erorile tehnice.
  • Unitatea de randomizare: utilizatorul, nu sesiunea, ca o persoană să vadă mereu aceeași variantă. Analiza se face pe aceeași unitate.
  • Efectul minim detectabil (MDE): cea mai mică îmbunătățire care merită implementarea. Împreună cu rata de bază, α = 0,05 și puterea de 80%, dă mărimea eșantionului.
PYTHON
from statsmodels.stats.power import NormalIndPower
from statsmodels.stats.proportion import proportion_effectsize, proportions_ztest

baza, mde = 0.30, 0.015                       # 30% -> 31,5%
h = proportion_effectsize(baza + mde, baza)
n = NormalIndPower().solve_power(effect_size=h, alpha=0.05, power=0.8, ratio=1)
print(round(n))                               # utilizatori per variantă

# la final: z, p = proportions_ztest([conv_b, conv_a], [n_b, n_a])
  • Durata: eșantionul împărțit la traficul zilnic, rotunjit la săptămâni complete, pentru că comportamentul diferă în weekend.
  • Verificări înainte de analiză: împărțirea efectivă a traficului corespunde celei planificate (sample ratio mismatch), varianta s-a afișat corect.
  • Analiza: diferența cu interval de încredere, nu doar p-value; segmentări doar ca explorare.
  • Decizia: stabilită dinainte, inclusiv ce faci dacă rezultatul e neutru.

Un A/A test (două variante identice) înainte de primul experiment verifică instrumentarea și randomizarea.

Ce urmărește intervievatorul: Verifică dacă poți proiecta un experiment complet, nu doar analiza unul. Greșeala tipică este calculul mărimii eșantionului după test sau lipsa lui.

79 Mid

Un coleg verifică zilnic rezultatele unui A/B test și vrea să-l oprească în ziua în care p scade sub 0,05. Ce problemă vezi?

Răspuns scurt: Problema se numește „peeking”: fiecare verificare e un nou test, așa că șansa de a vedea p < 0,05 măcar o dată din întâmplare crește mult peste 5%. Fie fixezi durata și analizezi o singură dată, fie folosești metode secvențiale proiectate pentru verificări repetate.

Valoarea p fluctuează pe parcursul unui experiment, chiar dacă nu există niciun efect. Dacă te uiți de 20 de ori și te oprești la prima valoare sub 0,05, rata reală de fals pozitive poate fi de câteva ori mai mare decât 5%. Poți verifica asta cu o simulare A/A:

PYTHON
import numpy as np
from statsmodels.stats.proportion import proportions_ztest
rng = np.random.default_rng(0)
fals_poz, sim = 0, 1000
for _ in range(sim):
    a = rng.random(20000) < 0.1
    b = rng.random(20000) < 0.1          # niciun efect real
    for n in range(1000, 20001, 1000):   # 20 de verificări
        _, p = proportions_ztest([a[:n].sum(), b[:n].sum()], [n, n])
        if p < 0.05:
            fals_poz += 1
            break
print(fals_poz / sim)   # mult peste 0.05

Soluții:

  • Durată fixă: calculezi eșantionul înainte, monitorizezi doar probleme tehnice și metrici de protecție și analizezi o singură dată.
  • Teste secvențiale de grup: câteva analize intermediare planificate, cu praguri mai stricte (de exemplu O'Brien-Fleming), care păstrează α total la 5%.
  • Metode „always valid”: teste secvențiale bazate pe raportul de verosimilitate sau intervale de încredere valabile în orice moment, folosite de multe platforme de experimentare.
  • Abordare bayesiană cu reguli de decizie stabilite dinainte; nici ea nu e complet imună la oprirea oportunistă.

Mai există un motiv practic de a nu opri devreme: efectele de noutate și diferențele dintre zilele săptămânii pot face ca rezultatul din primele zile să nu reprezinte comportamentul stabil.

Ce urmărește intervievatorul: Verifică disciplina experimentală. Mulți nu știu că verificarea repetată umflă rata de fals pozitive.

80 Mid

Cum evaluezi un sistem de recomandare sau de căutare? Ce sunt precision@k, recall@k și NDCG?

Răspuns scurt: Evaluezi calitatea primelor k rezultate: precision@k este proporția relevantă din primele k, recall@k este ce parte din itemii relevanți apar în primele k, iar NDCG ține cont și de poziție, recompensând rezultatele relevante plasate sus. Offline completezi cu acoperire și diversitate, online cu A/B test.

Utilizatorii văd doar primele câteva rezultate, deci metricile clasice de clasificare nu sunt potrivite.

  • Precision@k: din primele k recomandări, câte sunt relevante.
  • Recall@k: din toate itemele relevante pentru utilizator, câte au intrat în primele k.
  • MRR (mean reciprocal rank): 1 / poziția primului rezultat relevant, mediat pe interogări; bun când contează un singur răspuns corect.
  • NDCG@k: suma relevanțelor împărțită la log2(poziție + 1), normalizată la ordonarea ideală. Acceptă relevanță graduală (de exemplu: cumpărat = 3, adăugat în coș = 2, click = 1).
PYTHON
import numpy as np
def ndcg_at_k(relevante_in_ordine, k):
    rel = np.asarray(relevante_in_ordine, dtype=float)[:k]
    dcg = np.sum(rel / np.log2(np.arange(2, len(rel) + 2)))
    ideal = np.sort(np.asarray(relevante_in_ordine, dtype=float))[::-1][:k]
    idcg = np.sum(ideal / np.log2(np.arange(2, len(ideal) + 2)))
    return dcg / idcg if idcg > 0 else 0.0

print(round(ndcg_at_k([3, 0, 2, 0, 1], k=5), 3))

scikit-learn are și ndcg_score pentru matrice de scoruri.

Capcane ale evaluării offline:

  • Datele istorice sunt influențate de sistemul vechi: utilizatorii au dat click doar pe ce li s-a arătat (bias de expunere). Un item bun niciodată afișat pare irelevant.
  • Split-ul trebuie făcut temporal, nu aleator.
  • Acuratețea nu e totul: acoperirea catalogului, diversitatea, noutatea și popularitatea excesivă contează pentru experiență și business.

De aceea decizia finală se ia online, prin A/B test pe metrici ca rata de click, conversia sau timpul petrecut, metricile offline fiind un filtru pentru candidați.

Ce urmărește intervievatorul: Verifică familiaritatea cu probleme de ranking, foarte frecvente în produse. Greșeala tipică e evaluarea cu acuratețe sau cu split aleator.

81 Senior

Noul model are scoruri offline clar mai bune, dar în A/B test nu îmbunătățește metrica de business. Ce investighezi?

Răspuns scurt: Verifici implementarea și puterea experimentului, diferențele dintre feature-urile din antrenare și cele din producție, dacă metrica offline reflectă obiectivul de business și dacă datele de evaluare seamănă cu traficul real.

Ipoteze de verificat, ordonate aproximativ după frecvență:

  • Implementarea: modelul nou chiar rulează în varianta B? Versiunea, feature-urile, pragul sunt cele testate? Logurile de predicție arată distribuții de scor ca în offline?
  • Train-serving skew: un feature calculat altfel în producție (alt fus orar, altă fereastră, valori lipsă tratate diferit) poate anula avantajul. Compari feature-urile logate în producție cu cele din setul de antrenare pentru aceleași entități.
  • Metrica proxy greșită: AUC-ul măsoară ordonarea globală, dar decizia se ia doar pe primii 1% din clienți. Sau optimizezi click-ul, iar business-ul se măsoară prin achiziții.
  • Date de evaluare nereprezentative: split aleator în loc de temporal, leakage, distribuție schimbată între perioada de antrenare și cea a testului.
  • Bias de feedback: datele de antrenare au fost generate de modelul vechi; noul model e evaluat doar pe cazurile pe care cel vechi le-a ales.
  • Lanțul de decizie: îmbunătățirea predicției nu se transformă în acțiune. De exemplu, echipa de vânzări contactează oricum aceiași clienți, sau o regulă de business ulterioară suprascrie scorul.
  • Puterea experimentului: efectul real poate fi mai mic decât MDE-ul pentru care a fost dimensionat testul; un rezultat neutru nu dovedește lipsa efectului.
  • Efecte de interacțiune: alte experimente simultane, efect de noutate sau de obișnuință.

Ca să previi situația: înainte de a construi un model nou, stabilești cum se leagă metrica offline de cea online, de exemplu din experimentele anterioare, și construiești o evaluare offline care simulează politica de decizie, nu doar acuratețea predicției.

Ce urmărește intervievatorul: Întrebare senior despre experiență reală. Răspunsul bun e sistematic și include atât cauze tehnice, cât și de business.

82 Senior

Ce poate invalida un A/B test chiar dacă statistica e corectă? Explică sample ratio mismatch și alte capcane.

Răspuns scurt: Sample ratio mismatch (SRM) înseamnă că împărțirea observată a utilizatorilor diferă semnificativ de cea planificată, semn de bug. Alte capcane: analiză pe altă unitate decât randomizarea, efecte de rețea, efect de noutate, contaminare.

Sample ratio mismatch. Ai planificat 50/50 și ai 100.000 față de 97.500 de utilizatori. Un test chi-pătrat pe numărători arată dacă diferența e plauzibilă din întâmplare. Un p foarte mic indică o problemă: varianta B se încarcă mai greu și unii utilizatori pleacă înainte de a fi logați, un bot e filtrat doar într-o variantă, redirecționări pierd evenimente. Rezultatul experimentului nu mai e de încredere până afli cauza.

PYTHON
from scipy.stats import chisquare
obs = [100_000, 97_500]
print(chisquare(obs, f_exp=[sum(obs) / 2] * 2).pvalue)   # foarte mic: SRM

Alte capcane:

  • Unitatea de analiză diferă de unitatea de randomizare: randomizezi pe utilizatori, dar calculezi conversia pe sesiuni ca și cum ar fi independente. Erorile standard ies prea mici. Soluția: agregare pe utilizator, metoda delta sau bootstrap pe utilizatori.
  • Metrici raport (venit per sesiune): numitorul variază și el între grupuri, iar varianța trebuie calculată corect (metoda delta).
  • Efecte de rețea și interferență: pe o piață cu două părți (șoferi și pasageri, vânzători și cumpărători), varianta B poate „fura” resurse de la A. Se folosesc randomizare pe clustere geografice sau alternare în timp (switchback).
  • Efect de noutate sau de obișnuință: comportamentul din primele zile nu persistă; te uiți la evoluția efectului în timp.
  • Contaminare: același om pe două dispozitive vede ambele variante.
  • Valori extreme: câțiva clienți mari domină media venitului; winsorizare sau metrici robuste, decise dinainte.

Pentru reducerea varianței și teste mai scurte, metoda CUPED folosește comportamentul din perioada dinaintea experimentului ca variabilă de control.

Ce urmărește intervievatorul: Verifică experiența cu platforme reale de experimentare. Un senior verifică întâi validitatea experimentului și abia apoi rezultatul.

Modele în producție, Git și algoritmi

83 Junior

Cum folosești Git într-un proiect de data science? Ce pui în repository și ce nu?

Răspuns scurt: În Git pui codul, configurațiile, fișierele de dependențe, testele și notebook-urile curățate de output; nu pui date mari, modele binare, secrete sau fișiere generate. Pentru date și modele folosești stocare externă cu versionare (DVC, un registry de modele) și lucrezi pe branch-uri cu pull request-uri.

Git este făcut pentru fișiere text mici care se schimbă incremental. Un CSV de 2 GB sau un model de 500 MB umflă istoricul pentru totdeauna, chiar dacă le ștergi ulterior.

În repository:

  • codul din src/ (preprocesare, feature-uri, antrenare, servire), testele, scripturile;
  • configurații (YAML cu hiperparametri și căi), requirements.txt sau pyproject.toml cu versiuni fixate;
  • notebook-uri de explorare, de preferat fără output-uri (cu nbstripout) sau convertite în scripturi;
  • un README cu modul de rulare.

În afara repository-ului, prin .gitignore:

data/
models/*.joblib
.env
__pycache__/
.ipynb_checkpoints/
mlruns/
  • Secretele (parole de baze de date, chei API) stau în variabile de mediu sau într-un manager de secrete. Dacă o cheie a ajuns într-un commit, o consideri compromisă și o rotești; ștergerea din ultimul commit nu o scoate din istoric.
  • Datele și modelele se versionează cu DVC (care păstrează în Git doar fișiere mici cu hash-uri și trimite datele într-un bucket), cu un registry de modele (MLflow) sau cu Git LFS pentru fișiere mari ocazionale.

Fluxul de lucru: un branch per funcționalitate sau experiment, commit-uri mici cu mesaje clare, pull request cu review și teste automate. Un model din producție trebuie să poată fi legat de commit-ul de cod și de versiunea de date care l-au produs.

Ce urmărește intervievatorul: Verifică maturitatea inginerească. Greșeala tipică: date, modele sau chei API urcate direct în Git.

84 Junior

Cum salvezi un model antrenat și ce riscuri are pickle?

Răspuns scurt: În Python salvezi de obicei tot pipeline-ul cu joblib.dump, care folosește pickle. Riscurile: încărcarea unui pickle poate executa cod arbitrar, deci nu încarci fișiere din surse nesigure, iar fișierul depinde de versiunile bibliotecilor. Alternative portabile: ONNX, skops sau formatele native ale bibliotecilor.

PYTHON
import joblib
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)).fit(X, y)
joblib.dump(pipe, "model_v1.joblib")

incarcat = joblib.load("model_v1.joblib")
print(incarcat.predict(X[:3]))

Salvezi pipeline-ul complet, nu doar modelul, ca preprocesarea să fie identică în producție.

Riscuri și bune practici:

  • Securitate: pickle reconstruiește obiecte apelând funcții, iar un fișier construit rău-intenționat poate rula orice cod la load. Încarci doar artefacte produse de tine sau dintr-un registry controlat.
  • Compatibilitate: un model salvat cu o versiune de scikit-learn poate să nu se încarce sau să se comporte diferit cu alta. Fixezi versiunile în requirements.txt și le salvezi împreună cu modelul.
  • Metadate: alături de fișier păstrezi versiunea codului (commit), datele de antrenare, lista și ordinea feature-urilor, metricile pe validare și data antrenării.

Alternative:

  • skops pentru modele scikit-learn, cu încărcare mai sigură, care verifică tipurile permise;
  • ONNX, format portabil, rulabil din alte limbaje (Java, C#) și adesea mai rapid la inferență;
  • formate native: booster.save_model("model.json") în XGBoost sau LightGBM, torch.save(model.state_dict(), ...) în PyTorch, cu torch.load(..., weights_only=True) la încărcare.

Ce urmărește intervievatorul: Verifică dacă te gândești la ce se întâmplă după notebook. Puțini candidați junior știu de riscul de securitate al pickle.

85 Junior

Ce faci ca un experiment de machine learning să fie reproductibil?

Răspuns scurt: Fixezi seed-urile, versiunile bibliotecilor și versiunea datelor, ții codul în Git, muți logica din notebook în scripturi parametrizate prin fișiere de configurare și înregistrezi pentru fiecare rulare parametrii, metricile și artefactele, de exemplu cu MLflow.

Un rezultat pe care nu-l poți reproduce nu poate fi verificat, comparat sau pus în producție cu încredere. Surse de nereproductibilitate și remedii:

  • Aleatoriul: împărțirea datelor, inițializarea modelului, bootstrap-ul. Setezi random_state în scikit-learn și seed-urile în NumPy și PyTorch. Pe GPU, unele operații rămân nedeterministe, iar PyTorch are torch.use_deterministic_algorithms(True) cu un cost de viteză.
  • Mediul: versiuni fixate în requirements.txt sau uv.lock/poetry.lock, mediu virtual sau imagine Docker.
  • Datele: o interogare SELECT peste un tabel care se actualizează dă alt rezultat mâine. Salvezi un snapshot sau versionezi cu DVC și înregistrezi data și hash-ul.
  • Codul: notebook-urile rulate într-o ordine arbitrară a celulelor ascund stare. Explorarea rămâne în notebook, dar pipeline-ul final devine scripturi sau module rulabile de la zero.
  • Parametrii: într-un fișier de configurare, nu împrăștiați prin cod.
PYTHON
import random, numpy as np
import mlflow
SEED = 42
random.seed(SEED); np.random.seed(SEED)

with mlflow.start_run():
    mlflow.log_params({"model": "hgb", "learning_rate": 0.05, "seed": SEED})
    # ... antrenare ...
    mlflow.log_metric("val_auc", 0.871)
    # mlflow.sklearn.log_model(model, "model")

Testul simplu de reproductibilitate: un coleg clonează repository-ul, instalează dependențele, rulează o comandă și obține aceeași metrică. Mai trebuie spus că diferențe foarte mici de scor între rulări cu seed-uri diferite sunt normale; raportezi media și variabilitatea, nu cea mai bună rulare.

Ce urmărește intervievatorul: Verifică disciplina de lucru. Greșeala tipică este un notebook care funcționează doar pe laptopul autorului.

86 Junior

Scrie o funcție care primește o listă de numere și o țintă și întoarce indicii a două numere care adunate dau ținta. Ce complexitate are?

Răspuns scurt: Parcurgi lista o singură dată și ții într-un dicționar valorile văzute și indicii lor; pentru fiecare număr verifici dacă tinta - numar a apărut deja. Complexitatea este O(n) timp și O(n) memorie, față de O(n²) la varianta cu două bucle.

Soluția naivă verifică toate perechile cu două bucle, deci O(n²) comparații. Pentru un milion de elemente asta înseamnă de ordinul 10^12 operații, inacceptabil.

Observația: pentru fiecare număr x, căutăm complementul tinta - x. Un dicționar oferă căutare în timp mediu O(1).

PYTHON
def doua_suma(numere, tinta):
    vazute = {}                      # valoare -> index
    for i, x in enumerate(numere):
        complement = tinta - x
        if complement in vazute:
            return vazute[complement], i
        vazute[x] = i
    return None

print(doua_suma([2, 7, 11, 15], 9))    # (0, 1)
print(doua_suma([3, 3], 6))            # (0, 1)
print(doua_suma([1, 2, 3], 100))       # None

Detalii de discutat cu intervievatorul:

  • Verificarea se face înainte de inserare, ca să nu folosești același element de două ori (cazul [3] cu ținta 6).
  • Duplicatele sunt tratate corect: [3, 3] găsește perechea.
  • Dacă lista e deja sortată, poți folosi doi indici care pornesc de la capete: O(n) timp și O(1) memorie.
  • Cazurile limită: listă goală, nicio soluție, numere negative.

De ce apare o astfel de întrebare la un interviu de data science: verifică dacă înțelegi costul structurilor de date. Aceeași idee (un dicționar sau un set în loc de căutări repetate în liste) face diferența între un script de feature engineering care rulează în secunde și unul care rulează ore. În pandas, echivalentul unui join pe cheie folosește tot o tabelă hash.

Ce urmărește intervievatorul: Problema clasică de încălzire la secțiunea de algoritmi. Se urmărește trecerea de la soluția pătratică la cea liniară și explicarea complexității.

87 Mid

Cum expui un model ca API REST? Scrie un exemplu minimal.

Răspuns scurt: Încarci modelul o singură dată la pornirea serviciului, definești un endpoint care primește datele validate (de exemplu cu Pydantic în FastAPI), aplici pipeline-ul și întorci predicția. Adaugi un endpoint de health check, logare, versiunea modelului și împachetezi totul într-un container Docker.

Exemplu cu FastAPI (modelul salvat anterior cu joblib):

PYTHON
# app.py
import joblib
import pandas as pd
from fastapi import FastAPI
from pydantic import BaseModel, Field

MODEL_VERSIUNE = "churn-2026-10-01"
model = joblib.load("model_churn.joblib")    # o singură dată, la pornire
app = FastAPI()

class Client(BaseModel):
    varsta: int = Field(ge=18, le=110)
    venit: float = Field(ge=0)
    oras: str
    abonament: str

@app.get("/health")
def health():
    return {"status": "ok", "model": MODEL_VERSIUNE}

@app.post("/predict")
def predict(c: Client):
    X = pd.DataFrame([c.model_dump()])
    p = float(model.predict_proba(X)[0, 1])
    return {"probabilitate_churn": round(p, 4), "model": MODEL_VERSIUNE}

Rulare locală: uvicorn app:app --port 8000, apoi un POST cu JSON pe /predict. FastAPI generează automat documentația la /docs. model_dump() este metoda din Pydantic v2.

Ce mai contează în practică:

  • Validarea intrărilor cu Pydantic respinge datele greșite înainte să ajungă la model.
  • Ordinea și numele coloanelor trebuie să fie identice cu cele de la antrenare, motiv pentru care construiești DataFrame-ul cu aceleași nume.
  • Logarea intrărilor, predicțiilor și versiunii modelului, necesară pentru monitorizare și depanare.
  • Endpoint batch care acceptă o listă de înregistrări, mai eficient decât multe apeluri individuale.
  • Un Dockerfile cu versiuni fixate, teste automate și un mod de reîncărcare a modelului fără întreruperea serviciului.

Pentru modele mari sau trafic mare există servere specializate (de exemplu BentoML, TorchServe, Triton), dar logica de bază rămâne aceeași.

Ce urmărește intervievatorul: Verifică dacă poți duce un model dincolo de notebook. Greșeala tipică e încărcarea modelului la fiecare cerere.

88 Mid

Când alegi inferență batch și când inferență în timp real?

Răspuns scurt: Batch când predicțiile se pot calcula periodic, dinainte (scoruri de churn zilnice); în timp real când predicția depinde de date apărute chiar atunci și decizia se ia în milisecunde (fraudă la plată). Batch e mai simplu și mai ieftin.

Inferența batch: un job programat (cron, Airflow, Prefect) citește datele, calculează predicții pentru toate entitățile și le scrie într-un tabel. Aplicațiile citesc doar rezultatul.

  • Avantaje: simplă, ieftină, ușor de reluat dacă eșuează, poate folosi modele mari și feature-uri costisitoare, se poate verifica înainte de publicare.
  • Dezavantaje: predicțiile sunt „vechi” cu până la un ciclu; nu acoperă entități noi apărute între rulări; calculezi și pentru entități care nu vor fi folosite.

Inferența online (în timp real): un serviciu răspunde la cerere, în milisecunde.

  • Necesară când decizia depinde de context imediat: tranzacția curentă, căutarea tocmai făcută, conținutul coșului.
  • Cere un serviciu disponibil permanent, cu latență mică, scalare, monitorizare și feature-uri disponibile la momentul cererii, adesea dintr-un feature store online.
  • Riscul principal este train-serving skew: feature-urile calculate în timp real diferă de cele calculate în batch pentru antrenare.

Variante intermediare:

  • Streaming (Kafka, Flink): predicții declanșate de evenimente, cu întârziere de secunde.
  • Hibrid: feature-uri grele calculate în batch, combinate la cerere cu câteva feature-uri în timp real; sau predicții pre-calculate cu un model online doar pentru entitățile noi.

Întrebările de decizie: cât de repede se schimbă datele relevante, care este latența acceptată, câte entități sunt și cât costă o predicție învechită. Regula practică: începi cu batch dacă cerința o permite și treci la timp real doar când valoarea o justifică.

Ce urmărește intervievatorul: Verifică gândirea de arhitectură. Greșeala tipică e alegerea unui API în timp real când un tabel actualizat zilnic ar fi suficient.

89 Mid

Ce sunt data drift și concept drift și cum monitorizezi un model în producție?

Răspuns scurt: Data drift înseamnă schimbarea distribuției datelor de intrare; concept drift înseamnă schimbarea relației dintre intrări și țintă, deci aceleași date duc acum la alt rezultat. Monitorizezi calitatea datelor, distribuțiile feature-urilor și ale predicțiilor, iar când etichetele sosesc, performanța reală, cu alerte și reantrenare.

Un model e antrenat pe o fotografie a trecutului. Lumea se schimbă:

  • Data drift (covariate shift): apar mai mulți utilizatori de pe mobil, o campanie aduce clienți mai tineri, un partener schimbă formatul datelor. Modelul poate fi încă corect, dar lucrează în zone unde a văzut puține exemple.
  • Concept drift: aceleași caracteristici înseamnă altceva. Fraudatorii își schimbă tiparele, o criză economică modifică relația dintre venit și riscul de neplată.
  • Label shift: se schimbă prevalența țintei.

Ce monitorizezi, pe niveluri:

  • Sănătatea serviciului: latență, erori, volum de cereri.
  • Calitatea datelor: procent de valori lipsă, categorii noi, valori în afara intervalului, schimbări de schemă. Multe „drifturi” sunt de fapt bug-uri în amonte.
  • Distribuții: fiecare feature și scorul modelului, comparate cu perioada de referință, prin PSI (population stability index), testul Kolmogorov-Smirnov sau distanța Wasserstein.
  • Performanța reală, când sosesc etichetele (uneori după săptămâni): AUC, precision, calibrare, pe segmente.
PYTHON
import numpy as np
def psi(ref, curent, bins=10):
    margini = np.quantile(ref, np.linspace(0, 1, bins + 1))
    margini[0], margini[-1] = -np.inf, np.inf
    r = np.histogram(ref, margini)[0] / len(ref) + 1e-6
    c = np.histogram(curent, margini)[0] / len(curent) + 1e-6
    return float(np.sum((c - r) * np.log(c / r)))

Pe eșantioane mari, testele statistice semnalează diferențe minuscule; contează mărimea schimbării și efectul asupra deciziilor. Răspunsul la drift: investigare, reantrenare periodică sau declanșată, uneori revizuirea feature-urilor ori a definiției țintei.

Ce urmărește intervievatorul: Verifică dacă știi că munca nu se termină la deploy. Greșeala tipică e monitorizarea doar a disponibilității serviciului.

90 Mid

Scrie o funcție care întoarce cele mai frecvente k elemente dintr-o listă mare. Ce complexitate are?

Răspuns scurt: Numeri aparițiile cu un dicționar (Counter), în O(n), apoi extragi primele k cu un heap de mărime k, în O(m log k), unde m este numărul de valori distincte. E mai eficient decât sortarea completă a tuturor valorilor, O(m log m), când k este mic.

PYTHON
from collections import Counter
import heapq

def top_k_frecvente(elemente, k):
    contor = Counter(elemente)                       # O(n)
    return heapq.nlargest(k, contor.items(), key=lambda kv: kv[1])   # O(m log k)

cautari = ["laptop", "telefon", "laptop", "casti", "telefon", "laptop", "mouse"]
print(top_k_frecvente(cautari, 2))   # [('laptop', 3), ('telefon', 2)]

Variante și discuție:

  • Counter.most_common(k) face același lucru și folosește intern heapq.nlargest când k este dat.
  • Implementare manuală a heap-ului: păstrezi un min-heap de mărime k; pentru fiecare pereche (frecvență, element), dacă heap-ul are deja k elemente și frecvența e mai mare decât minimul, îl înlocuiești cu heapq.heappushpop. Rezultatul are memorie O(k) pentru heap.
  • Bucket sort după frecvență: frecvențele sunt între 1 și n, deci poți grupa elementele pe frecvență și parcurge de la cea mai mare, în O(n) total.
  • La egalitate de frecvență, specifici o regulă (de exemplu ordinea alfabetică) dacă rezultatul trebuie determinist.

Pentru volume care nu încap în memorie sau pentru fluxuri continue, discuția devine interesantă la nivel mid: poți număra pe bucăți și combina contoarele (ca un map-reduce), poți folosi SQL (GROUP BY cu ORDER BY COUNT(*) DESC LIMIT k) sau algoritmi aproximativi cu memorie fixă, cum sunt Count-Min Sketch și Space-Saving, acceptând o eroare mică.

SQL
SELECT termen, COUNT(*) AS n FROM cautari GROUP BY termen ORDER BY n DESC LIMIT 10;

Ce urmărește intervievatorul: Verifică stăpânirea structurilor de date din biblioteca standard și analiza complexității. Răspunsul bun discută și scalarea la date mari.

91 Senior

Ce este train-serving skew și cum te ajută un feature store?

Răspuns scurt: Train-serving skew apare când feature-urile sau preprocesarea diferă între antrenare și producție. Un feature store definește o singură dată fiecare feature și îl servește consecvent: istoric, point-in-time, pentru antrenare și cu latență mică pentru inferență.

Cauze tipice de skew:

  • Cod duplicat: feature-urile de antrenare sunt calculate în SQL de data scientist, iar cele din producție reimplementate în Java de echipa de backend. Mici diferențe (rotunjiri, fus orar, tratarea valorilor lipsă, ferestre de 30 de zile calendaristice versus 30 de zile de activitate) schimbă valorile.
  • Date disponibile diferit în timp: în tabelul istoric, un câmp e completat retroactiv, iar la momentul real al predicției încă lipsește.
  • Surse diferite: antrenare din warehouse, inferență din baza operațională.
  • Preprocesare separată de model: scalarea sau codificarea sunt aplicate manual în aplicație.

Cum îl previi:

  • Preprocesarea împachetată în același artefact cu modelul (pipeline scikit-learn, grafic ONNX).
  • Logarea feature-urilor exact cum au fost servite și folosirea acestor loguri pentru antrenările viitoare.
  • Teste care compară, pentru un eșantion de entități, valorile calculate offline cu cele servite online.

Feature store-ul (de exemplu Feast sau soluțiile oferite de platformele cloud) are două componente:

  • un magazin offline, cu istoricul valorilor fiecărui feature și momentul în care au devenit disponibile, din care se construiesc seturi de antrenare cu join-uri point-in-time, fără leakage;
  • un magazin online, cu valorile curente, citite în milisecunde la inferență.

Definiția feature-ului e scrisă o dată și folosită de ambele, iar feature-urile devin reutilizabile între echipe. Costul: infrastructură și disciplină în plus. Pentru o echipă mică, cu un singur model batch, un tabel bine documentat și același cod de transformare pentru antrenare și scoring pot fi suficiente.

Ce urmărește intervievatorul: Verifică experiența cu sisteme ML reale. Mulți au întâlnit problema fără să-i știe numele; un senior știe și când un feature store nu merită.

92 Senior

Cum pui în producție în siguranță o versiune nouă a unui model și cum faci rollback?

Răspuns scurt: Versionezi modelul într-un registry, treci prin validări automate și îl lansezi treptat: shadow (calculează fără să decidă), canary pe puțin trafic sau A/B test. Rollback-ul înseamnă revenirea instantă la versiunea anterioară, păstrată gata de servire.

Un flux matur arată astfel:

  • Antrenare reproductibilă dintr-un pipeline automat (CI sau orchestrator), cu parametrii, versiunea datelor și commit-ul de cod înregistrate, de exemplu în MLflow.
  • Registry de modele: fiecare versiune are un identificator, artefactele, metricile și o etapă (candidat, producție, arhivat). Aplicația cere „modelul de producție”, nu un fișier anume.
  • Porți de validare automate înainte de promovare: scor pe un set de test fix cel puțin egal cu modelul curent, performanță pe segmente importante (fără regresii pe un grup anume), calibrare, latență și dimensiune, teste pe cazuri limită (valori lipsă, categorii noi).
  • Lansare treptată:
  • shadow: noul model primește traficul real și își loghează predicțiile, dar decizia o ia modelul vechi; compari distribuțiile și erorile fără risc;
  • canary: 1-5% din trafic, cu monitorizare atentă, apoi creștere treptată;
  • A/B test când vrei să măsori impactul de business.
  • Rollback: versiunea anterioară rămâne încărcată sau imediat disponibilă, iar schimbarea se face printr-o configurare (un alias sau un feature flag), nu printr-un deploy nou. Se definesc dinainte criteriile de rollback automat (rata de erori, schimbări bruște în distribuția scorurilor).

Mai trebuie avute în vedere: compatibilitatea schemei de intrare între versiuni, consumatorii scorului (dacă scala sau calibrarea se schimbă, pragurile din aplicații trebuie ajustate), documentația modelului (model card) și cine aprobă promovarea. La nivel senior contează să explici că un model este un artefact software cu ciclu de viață complet, nu un fișier copiat pe server.

Ce urmărește intervievatorul: Verifică maturitatea MLOps. Răspunsul slab înlocuiește direct fișierul modelului pe server și speră că merge.

Comportamentale și HR

93 Junior

Povestește-mi despre un proiect de data science de care ești mândru.

Răspuns scurt: Alegi un proiect real și îl povestești structurat: contextul și întrebarea de business, datele, abordarea și alternativele respinse, rezultatul măsurabil și ce ai învățat. Contribuția ta personală trebuie să fie clară, iar detaliile tehnice adaptate interlocutorului.

Intervievatorul vrea să vadă cum gândești de la cap la coadă, nu o listă de biblioteci. O structură care funcționează (variantă a metodei STAR: situație, sarcină, acțiune, rezultat):

  • Context și problemă: „Pentru un proiect personal am analizat datele publice despre închirierile de biciclete și am vrut să prezic cererea pe stații pe oră, ca să înțeleg când ar trebui redistribuite.”
  • Datele: sursa, volumul, problemele găsite (lipsuri, stații redenumite, ore fără date) și cum le-ai rezolvat.
  • Abordarea: baseline-ul (media pe oră și zi a săptămânii), apoi modelul ales și de ce, validarea temporală, metrica și de ce ea.
  • Rezultatul: comparația cu baseline-ul, în cifrele reale ale proiectului tău, plus ce înseamnă practic.
  • Ce ai învățat și ce ai face diferit: de exemplu, că feature-urile meteo au contat mai mult decât modelul sau că ai pierdut timp pe tuning înainte să analizezi erorile.

Pentru un junior fără experiență profesională, un proiect personal sau de curs e perfect valabil dacă îl stăpânești: codul pe GitHub, un README clar și capacitatea de a răspunde la „de ce?” pentru fiecare decizie. Pregătește-te pentru întrebări de aprofundare: ce s-ar întâmpla cu date de două ori mai multe, cum ai pune modelul în producție, ce ai testa mai departe.

Greșeli de evitat: „noi am făcut” fără să spui ce ai făcut tu, cifre pe care nu le poți explica, accent exclusiv pe algoritm și nimic despre problemă sau impact.

Ce urmărește intervievatorul: Verifică dacă poți comunica structurat și dacă proiectul e cu adevărat al tău. Întrebările de aprofundare scot rapid la iveală proiectele copiate.

94 Junior

De ce vrei să lucrezi ca data scientist și ce te atrage la acest rol?

Răspuns scurt: Răspunzi concret și onest: ce tip de probleme te atrage, ce ai făcut deja ca să te apropii de domeniu și cum se leagă asta de rolul și compania la care aplici. Evită răspunsurile generice despre „viitorul AI” sau despre salariu.

Întrebarea verifică motivația și dacă ai o imagine realistă despre meserie. Mulți își imaginează că data science înseamnă mai ales modele sofisticate, deși o mare parte din timp se duce pe înțelegerea problemei, curățarea datelor, SQL, comunicare și punerea rezultatelor în practică.

Structură recomandată:

  • Ce te atrage, concret: „Îmi place momentul în care o întrebare vagă de business devine o întrebare la care datele pot răspunde” sau „Mă interesează experimentele: să aflu dacă o schimbare chiar funcționează.”
  • Dovezi: ce ai făcut deja. Cursuri parcurse, un proiect personal, o analiză făcută la jobul actual (de exemplu, ai automatizat un raport în Excel cu Python), o competiție, un articol scris.
  • Legătura cu firma: ai citit despre produsul lor și vezi ce tip de probleme de date ar putea avea (recomandări, prognoză, fraudă, prețuri). Arată că ai făcut temele, fără să inventezi detalii interne.
  • Direcția: ce vrei să înveți în următorii ani, de exemplu experimentare sau punerea modelelor în producție.

Pentru cei care se reprofilează (din contabilitate, inginerie, marketing, cercetare), experiența anterioară este un avantaj: cunoașterea domeniului contează mult în data science. Spune explicit ce aduci din fostul rol.

Evită: „AI-ul este viitorul”, „se câștigă bine”, „mi-a plăcut matematica în liceu” fără nimic după. Nu sunt neapărat false, dar nu te deosebesc de ceilalți candidați.

Ce urmărește intervievatorul: Verifică motivația și realismul așteptărilor. Răspunsul slab este generic și nu pomenește nimic din ce a făcut candidatul.

95 Junior

Cum ai explica rezultatele unui model unui manager care nu are pregătire tehnică?

Răspuns scurt: Pornești de la decizia pe care trebuie s-o ia, prezinți rezultatul în termenii lui (bani, clienți, timp), folosești un exemplu concret și un grafic simplu, spui cât de sigur ești și ce limite are modelul, apoi recomanzi pașii următori. Fără jargon.

Managerul nu are nevoie să știe ce este AUC; are nevoie să știe ce să facă și cât de mult se poate baza pe recomandare.

Structură:

  • Concluzia întâi: „Dacă sunăm în fiecare săptămână primii 300 de clienți din lista modelului, estimăm că vom ajunge la aproximativ de trei ori mai mulți clienți care sunt pe punctul de a pleca decât acum, cu același efort.” (folosești cifrele reale din analiza ta, nu cifre inventate).
  • Ce face modelul, într-o frază: „Se uită la comportamentul din ultimele luni (cât de des intră, ce probleme au raportat) și dă fiecărui client un scor de risc.”
  • Un exemplu concret: un client tipic cu scor mare și motivele principale.
  • Incertitudinea: „Din 10 clienți marcați, cam 4 chiar ar pleca. Nu e perfect, dar e mult peste lista actuală.” Exprimarea în frecvențe naturale („4 din 10”) se înțelege mai bine decât procentele.
  • Limitele: unde greșește modelul, ce date nu are, când trebuie reantrenat.
  • Recomandarea și pașii următori: un pilot pe o regiune, cu un grup de control, ca să măsurăm efectul real.

Graficul ajută dacă e unul singur și simplu: de exemplu, câți clienți care pleacă prindem dacă sunăm primii 100, 200, 300 de pe listă.

Verifici înțelegerea punând întrebări („Ce v-ar ajuta să decideți?”), nu întrebând „E clar?”. Dacă vine o întrebare la care nu știi răspunsul, spui că verifici și revii.

Ce urmărește intervievatorul: Comunicarea este jumătate din meserie. Greșeala tipică e prezentarea metricilor tehnice și a arhitecturii modelului în fața unui public de business.

96 Mid

Povestește despre un model sau o analiză care nu a funcționat cum te așteptai. Ce ai făcut?

Răspuns scurt: Alegi un caz real, descrii pe scurt ce ai presupus și ce s-a întâmplat de fapt, cum ai descoperit problema, ce ai făcut ca s-o rezolvi și ce ai schimbat în modul de lucru după aceea. Asumarea onestă contează mai mult decât un final fericit.

Întrebarea verifică onestitatea, capacitatea de depanare și dacă înveți din greșeli. Toată lumea are astfel de povești; lipsa uneia ridică semne de întrebare.

Structură (STAR, cu accent pe lecție):

  • Situația: „Am construit un model de prognoză a vânzărilor care avea erori mici pe validare.”
  • Ce nu a mers: „În prima lună de folosire, erorile au fost mult mai mari decât în testare.”
  • Investigația: „Am comparat feature-urile din producție cu cele din antrenare și am descoperit că pentru promoții foloseam în antrenare tabelul final, completat după încheierea campaniei, iar în producție informația nu exista încă la momentul prognozei.” Arată pașii concreți: ipoteze, verificări, cum ai eliminat variantele.
  • Rezolvarea: ai reconstruit setul de antrenare cu datele disponibile la momentul predicției, ai reantrenat, ai comunicat problema echipei și ai estimat impactul.
  • Lecția și schimbarea de proces: „De atunci verific pentru fiecare feature momentul în care devine disponibil și rulez un test care compară valorile offline cu cele servite.”

Exemplul de mai sus este ilustrativ; folosește o întâmplare reală din experiența ta, chiar și dintr-un proiect personal (un model care părea excelent până ai descoperit duplicate între train și test este un exemplu bun).

De evitat: să dai vina pe alții, să alegi o „greșeală” falsă („lucrez prea mult”), să nu ai nicio lecție concretă. Faptul că ai comunicat problema devreme, chiar dacă era jenant, este un punct forte.

Ce urmărește intervievatorul: Verifică asumarea, gândirea de depanare și învățarea. Răspunsul slab ascunde greșeala sau o pune pe seama altora.

97 Mid

Un stakeholder îți cere să confirmi prin date o decizie pe care a luat-o deja, dar analiza ta arată altceva. Cum procedezi?

Răspuns scurt: Verifici întâi riguros analiza, apoi discuți rezultatele cu stakeholder-ul în privat, înainte de orice prezentare publică, pornind de la obiectivul comun. Prezinți datele, ipotezele și limitele transparent, propui o cale de testare (de exemplu un pilot) și nu modifici concluzia ca să o mulțumești.

Situația e frecventă și testează integritatea și abilitatea de a lucra cu oameni.

Pași:

  • Verifică-te întâi: datele corecte, definițiile metricilor aceleași cu ale lui, perioada potrivită, segmentele relevante. Cere unui coleg să-ți verifice raționamentul. Dacă greșești tu, mai bine afli acum.
  • Înțelege-i perspectiva: ce l-a convins de decizie? Poate are informații pe care datele nu le surprind (feedback de la clienți, o constrângere strategică). Întreabă-l ce rezultat ar considera un semn că decizia nu funcționează.
  • Discuție privată, înainte de ședință: nimeni nu vrea să fie contrazis public. Pornește de la obiectivul comun: „Amândoi vrem ca lansarea să crească vânzările. Am găsit ceva ce cred că trebuie să vedeți înainte.”
  • Transparență: arată datele, ipotezele și cât de sigur ești. Nu exagera: „datele nu susțin creșterea de 20% estimată; vedem un efect mic, iar intervalul include zero.”
  • Propune o soluție: un pilot cu grup de control, un A/B test, o lansare pe o singură regiune. Transformi conflictul într-o întrebare la care se poate răspunde.
  • Documentează analiza și concluzia, astfel încât decizia finală, oricare ar fi ea, să fie luată în cunoștință de cauză.

Decizia aparține de obicei business-ului. Rolul tău este să te asiguri că este informată corect, nu să câștigi disputa. Ce nu faci: să alegi doar perioada sau segmentul care confirmă ipoteza, să ascunzi rezultatul sau să-l prezinți ca pe o acuzație.

Ce urmărește intervievatorul: Verifică integritatea și abilitățile de influențare. Ambele extreme sunt greșite: cedarea și ajustarea datelor sau confruntarea publică.

98 Mid

Ai un termen strâns, iar datele sunt incomplete și pline de erori. Cum îți prioritizezi munca?

Răspuns scurt: Clarifici ce decizie trebuie luată și ce nivel de precizie e suficient, livrezi rapid o primă versiune simplă cu limitele scrise explicit, corectezi doar problemele de date care schimbă concluzia și comunici devreme riscurile și compromisurile, cu un plan pentru versiunea îmbunătățită.

Intervievatorul vrea să vadă pragmatism, nu perfecționism și nici neglijență.

Abordare:

  • Clarifică scopul: ce decizie se ia pe baza analizei și când? Un răspuns direcțional („crește sau scade?”) cere mult mai puțin decât o prognoză precisă pentru buget.
  • Triază problemele de date după impact: unele erori afectează concluzia (duplicatele care dublează vânzările unei regiuni), altele sunt cosmetice (nume de produse scrise inconsecvent). Le rezolvi pe primele, le notezi pe celelalte.
  • Începe simplu: o analiză descriptivă sau un baseline robust, livrat devreme, valorează mai mult decât un model complex care întârzie. Îl poți îmbunătăți iterativ.
  • Fă testele de sensibilitate: dacă rezultatul rămâne același și cu și fără datele suspecte, poți merge înainte cu încredere. Dacă se schimbă, asta e informația cea mai importantă de comunicat.
  • Comunică devreme: „Pot livra până joi o estimare cu o marjă de incertitudine mai mare, cu aceste trei limitări. Pentru o versiune solidă am nevoie de încă o săptămână și de acces la tabelul X.” Lași stakeholder-ul să aleagă compromisul în cunoștință de cauză.
  • Documentează: ipotezele, curățările făcute și problemele rămase, ca să poată fi reluate.
  • Rezolvă cauza, după termen: raportează problemele de date echipei care le produce, ca să nu le repari manual de fiecare dată.

Un exemplu personal (o temă, un proiect cu termen) face răspunsul credibil. Arată că ai ales conștient ce să nu faci.

Ce urmărește intervievatorul: Verifică pragmatismul și comunicarea compromisurilor. Răspunsul slab fie promite tot la termen, fie blochează proiectul până la date perfecte.

99 Senior

Cum îți dai seama că o problemă nu are nevoie de machine learning? Dă un exemplu în care ai recomandat altceva.

Răspuns scurt: Nu ai nevoie de ML când o regulă simplă sau un raport rezolvă suficient de bine problema, când lipsesc date sau etichete de calitate, când decizia nu depinde de predicție ori când întreținerea costă mai mult decât aduce.

O parte importantă din seniority este să știi când să nu construiești un model.

Semnale că ML nu e soluția potrivită (cel puțin încă):

  • O regulă simplă rezolvă aproape tot: „clienții fără autentificare de 30 de zile” prinde majoritatea cazurilor de churn, iar modelul ar adăuga puțin.
  • Problema e de date sau de proces: rapoartele contrazic pentru că definițiile diferă între departamente; un model peste date proaste produce rezultate proaste, mai greu de depistat.
  • Nu există acțiune: chiar cu o predicție perfectă, nimeni nu ar face nimic diferit.
  • Lipsesc etichetele și nu există o modalitate rezonabilă de a le obține.
  • Erorile sunt inacceptabile și trebuie explicate în fiecare caz, iar o regulă deterministă e cerută (de exemplu, unele verificări de conformitate).
  • Costul total (date, infrastructură, monitorizare, reantrenare, oameni) depășește câștigul estimat.

Exemplu de structură de răspuns: „Mi s-a cerut un model de prognoză a cererii pentru un produs nou. Am arătat că aveam doar câteva săptămâni de istoric și că decizia (comanda lunară) suporta o marjă mare. Am propus o regulă pe baza vânzărilor produselor similare plus o revizuire lunară. Am economisit timpul echipei și am revenit la un model după ce s-au acumulat date suficiente.” Folosește un exemplu real din experiența ta.

Mesajul pentru intervievator: tu optimizezi pentru impact, nu pentru complexitate tehnică. Analiza descriptivă bună, un experiment bine făcut sau o automatizare simplă sunt adesea cea mai valoroasă livrare a unui data scientist.

Ce urmărește intervievatorul: Verifică judecata de senior. Candidații care vor mereu un model, indiferent de context, sunt un semnal de alarmă.

100 Senior

Cum ajuți un data scientist junior din echipă să crească? Cum faci review la munca lui?

Răspuns scurt: Stabilești împreună obiective clare, îi dai proiecte cu responsabilitate reală și suport gradual, faci review-uri regulate pe cod și pe raționament prin întrebări, nu prin rescrierea muncii lui, și creezi un mediu în care poate spune devreme că s-a blocat sau a greșit.

La nivel senior se așteaptă să multiplici impactul echipei, nu doar să livrezi individual.

Ce funcționează în mentorat:

  • Obiective explicite: ce vrea să învețe în următoarele luni (SQL avansat, experimentare, punerea modelelor în producție) și ce înseamnă „bine” pentru rolul lui.
  • Proiecte potrivite: suficient de dificile ca să învețe, suficient de bine delimitate ca să poată reuși. Responsabilitatea crește treptat, de la sarcini clar definite la probleme deschise.
  • Întâlniri regulate, scurte, în care întrebi „unde te-ai blocat?” și „ce ai încerca?”, înainte să dai soluția.
  • Siguranță psihologică: împărtășești propriile greșeli; o problemă semnalată devreme este lăudată, nu sancționată.

Review la o analiză sau la cod:

  • Raționamentul înainte de sintaxă: întrebarea de business e corect formulată? Metrica e potrivită? Există leakage? Validarea imită producția?
  • Întrebări în loc de verdicte: „Ce s-ar întâmpla cu acest feature pentru un client nou?” îl învață să găsească singur problema.
  • Prioritizarea comentariilor: separi problemele care schimbă concluzia de preferințele de stil. Un review cu 40 de comentarii egale descurajează.
  • Laudă specifică pentru ce a făcut bine, ca să știe ce să repete.
  • Standarde scrise: o listă de verificare pentru analize și un șablon de proiect reduc comentariile repetitive.

Pregătește un exemplu concret din experiența ta: cum ai ajutat pe cineva să treacă de la o analiză ad-hoc într-un notebook la un pipeline reproductibil, ce ai schimbat în abordare când prima metodă nu a mers și cum s-a văzut progresul.

Ce urmărește intervievatorul: Verifică leadership-ul tehnic și empatia. Răspunsul slab descrie doar corectarea greșelilor, nu dezvoltarea autonomiei.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Data Scientist / ML Engineer

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Data Scientist / ML Engineer, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Data Scientist / ML Engineer

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.