Cum arată codul de Machine Learning?

Vestea bună: nu trebuie să implementezi algoritmii de ML de la zero. Ei sunt deja implementați în biblioteci precum scikit-learn, iar tu doar îi apelezi pe datele tale. Tot ce poți personaliza sunt de obicei niște parametri.

Totuși, recomandăm să încerci să implementezi fiecare algoritm măcar o dată, pentru a înțelege cu adevărat cum funcționează.

De ce ar trebui să înțelegi cum funcționează un model? Pentru a ști ce model să alegi pentru fiecare problemă. În funcție de caracteristicile datelor tale, unele modele vor funcționa mai bine decât altele.

Structura tipică a codului ML

Aproape orice proiect de Machine Learning urmează aceiași pași:

1. Încarcă datele
2. Împarte datele în train/validation/test
3. Curăță și pregătește datele
4. Antrenează modelul
5. Evaluează performanța
6. Generează predicții

Hai să trecem prin fiecare pas:

Pasul 1: Importă bibliotecile

import pandas as pd

pandas este biblioteca standard pentru lucrul cu date tabulare (tabele). O folosim pentru a citi, modifica și salva fișiere CSV, Excel etc.

Pasul 2: Încarcă datele

df_train = pd.read_csv('train.csv')
df_test = pd.read_csv('test.csv')

În problemele de ML primești de obicei două seturi de date:

Set	Conține labels?	Scop
Train	Da	Antrenezi modelul pe aceste date
Test	Nu	Generezi predicții pentru evaluare

De ce nu are test labels? Pentru că simulează viața reală - când folosești modelul în practică, nu știi răspunsul corect (altfel de ce ai mai avea nevoie de model?).

Pasul 3: Împarte datele în train și validation

from sklearn.model_selection import train_test_split

label = 'Numele_coloanei_cu_raspunsuri'
train, validation = train_test_split(df_train, test_size=0.2, random_state=0)

y_train = train[label]
X_train = train.drop(columns=[label])

y_validation = validation[label]
X_validation = validation.drop(columns=[label])

De ce împărțim datele de train?

Nu putem verifica dacă modelul funcționează pe datele de test (nu avem labels). Soluția: împărțim datele de train în două:

Train (80%) - antrenăm modelul
Validation (20%) - verificăm cât de bine funcționează

Ce înseamnă X și y?

Variabilă	Ce conține	Exemplu
`X`	Features (caracteristicile)	Vârsta, salariul, orașul
`y`	Labels (răspunsurile)	A cumpărat produsul? (Da/Nu)

Ce face `random_state=0`?

Asigură că împărțirea datelor e aceeași de fiecare dată când rulezi codul. Util pentru reproducibilitate.

Pasul 4: Curăță și pregătește datele

# Aici procesezi datele:
# - Transformi textul în numere
# - Completezi valorile lipsă (None/NaN)
# - Normalizezi valorile
# - Elimini coloanele inutile

Modelele ML lucrează doar cu numere. Dacă ai date de tip text, trebuie să le transformi. Dacă ai valori lipsă, trebuie să le completezi sau să elimini acele rânduri.

Vom detalia tehnicile de procesare în capitolele următoare.

Pasul 5: Antrenează și evaluează modelul

from sklearn.metrics import accuracy_score

model = ClasaDeModel()           # Creezi modelul
model = model.fit(X_train, y_train)    # Antrenezi pe datele de train
y_pred = model.predict(X_validation)   # Prezici pe datele de validation
print(accuracy_score(y_pred, y_validation))  # Compari cu răspunsurile reale

Cei 3 pași esențiali

Pas	Metodă	Ce face
1	`model = ClasaDeModel()`	Creezi o instanță a modelului
2	`model.fit(X, y)`	Antrenezi modelul pe date
3	`model.predict(X)`	Generezi predicții pentru date noi

Ce este acuratețea?

Acuratețe = Predicții corecte / Total predicții

Rezultatul e între 0 și 1: - 1.0 = toate predicțiile corecte (100%) - 0.5 = jumătate corecte (ca și cum ai ghici la întâmplare pentru 2 clase) - 0.0 = toate greșite

Pasul 6: Generează predicții pentru submission

# Prezice pe datele de test
predictions = model.predict(X_test)

# Creează DataFrame cu formatul cerut
df_submission = pd.DataFrame({
    "id": X_test.index,
    "prediction": predictions
})

# Salvează ca CSV
df_submission.to_csv("submission.csv", index=False)

După ce ești mulțumit de performanța modelului pe validation, generezi predicții pe datele de test și le salvezi într-un fișier CSV pe care îl trimiți la evaluare.

Exemplu complet

Iată cum arată un cod complet pentru o problemă de clasificare:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# 1. Încarcă datele
df_train = pd.read_csv('train.csv')
df_test = pd.read_csv('test.csv')

# 2. Împarte în train/validation
label = 'target'
train, validation = train_test_split(df_train, test_size=0.2, random_state=42)

X_train = train.drop(columns=[label])
y_train = train[label]
X_validation = validation.drop(columns=[label])
y_validation = validation[label]

# 3. Antrenează modelul
model = DecisionTreeClassifier()
model.fit(X_train, y_train)

# 4. Evaluează pe validation
y_pred = model.predict(X_validation)
print(f"Acuratețe: {accuracy_score(y_validation, y_pred):.2%}")

# 5. Generează submission
X_test = df_test.drop(columns=[label], errors='ignore')
predictions = model.predict(X_test)

submission = pd.DataFrame({
    "id": df_test.index,
    "prediction": predictions
})
submission.to_csv("submission.csv", index=False)

Rezumat: Pattern-ul ML

Indiferent de model, structura codului rămâne aceeași:

# Toate modelele din sklearn urmează același pattern:
model = NumeModel()          # Creează model
model.fit(X_train, y_train)  # Antrenează
predictions = model.predict(X_new)  # Prezice

Singura diferență între modele este cum învață din date - și asta vei învăța în capitolele următoare.