Regresie logistică

Regresia logistică transformă o dreaptă într-o curbă în formă de S pentru a răspunde probabilistic la întrebări cu „da” sau „nu”.

Tip: Construire Limbaje: Python Cerințe preliminare: Faza 2, lecțiile 1–2 (Ce este ML, Regresie liniară) Durată: ~90 de minute

Obiective de învățare

• Să implementați regresia logistică de la zero, folosind funcția sigmoidă și pierderea de entropie încrucișată binară
• Să calculați și să interpretați precizia, rapelul, scorul F1 și matricea de confuzie pentru clasificarea binară
• Să explicați de ce MSE este nepotrivită pentru clasificarea logistică și de ce entropia încrucișată binară produce un obiectiv convex
• Să construiți un model de regresie softmax pentru clasificarea cu mai multe clase și să evaluați compromisurile reglării pragului

Problema

Doriți să preziceți dacă o tumoare este malignă sau benignă pe baza dimensiunii sale. Încercați regresia liniară, dar aceasta produce numere precum 0,3, 1,7 sau −0,5. Ce înseamnă ele? Este 1,7 „foarte malign”, iar −0,5 „foarte benign”? Regresia liniară produce valori nelimitate. Regresia logistică oferă scoruri probabilistice între 0 și 1 și, prin alegerea unui prag, o decizie clară: da sau nu.

Regresia logistică rezolvă această problemă. Ea pornește de la aceeași combinație liniară, wx + b, și o trece prin funcția sigmoidă, care comprimă orice număr în intervalul (0, 1). Rezultatul poate fi interpretat drept probabilitate în condițiile modelului. Alegeți un prag, adesea 0,5, și luați o decizie.

Acesta este unul dintre algoritmii folosiți pe scară largă în practică. În pofida numelui, regresia logistică este un algoritm de clasificare, nu de regresie în terminologia ML. Numele provine de la funcția logistică, sau sigmoidă, pe care o utilizează.

Notă tehnică a traducerii: clasificarea nu necesită în general estimări probabilistice; acestea sunt oferite de formularea probabilistică a regresiei logistice. O ieșire sigmoidă nu este automat o probabilitate bine calibrată pe date noi. Interpretarea probabilistică depinde de adecvarea modelului și a datelor, iar calibrarea trebuie verificată, de exemplu prin diagrame de fiabilitate și metrici adecvate.

Conceptul

De ce regresia liniară nu este potrivită pentru clasificare

Imaginați-vă că preziceți promovarea sau nepromovarea unui examen, 1 sau 0, în funcție de orele de studiu. Regresia liniară potrivește o dreaptă datelor:

ore:       1   2   3   4   5   6   7   8   9   10
rezultat:  0   0   0   0   1   1   1   1   1   1

O dreaptă ajustată ar putea produce predicții precum −0,2 pentru o oră și 1,3 pentru zece ore. Aceste valori nu sunt probabilități: scad sub 0 și depășesc 1. În plus, o observație cu influență mare, de exemplu o persoană care a studiat 50 de ore, poate deplasa dreapta și poate modifica predicțiile pentru ceilalți.

Pentru clasificare este utilă o funcție care:

• Produce valori între 0 și 1, interpretabile condiționat ca probabilități
• Permite definirea unei frontiere de decizie printr-un prag
• Atenuează contribuția unor exemple corect clasificate aflate departe de frontieră

Notă tehnică: Regresia logistică nu este în general robustă la toate valorile aberante. Punctele cu levier ridicat, etichetele eronate și observațiile clasificate greșit cu încredere pot influența puternic coeficienții; regularizarea și analiza datelor rămân necesare.

Funcția sigmoidă

Funcția sigmoidă realizează această comprimare:

sigmoid(z) = 1 / (1 + e^(-z))

Proprietăți:

• Când z este mare și pozitiv, sigmoid(z) se apropie de 1
• Când z este mare și negativ, sigmoid(z) se apropie de 0
• Când z = 0, sigmoid(z) = 0,5
• Rezultatul este întotdeauna între 0 și 1
• Funcția este netedă și derivabilă peste tot

Derivata are o formă convenabilă: sigmoid’(z) = sigmoid(z) * (1 - sigmoid(z)). Acest lucru face eficient calculul gradientului.

Regresie logistică = model liniar + sigmoidă

Modelul calculează z = wx + b, ca în regresia liniară, apoi aplică sigmoida:

Rezultatul p modelează P(y=1 | x), probabilitatea condiționată ca intrarea să aparțină clasei 1. Frontiera pentru pragul 0,5 se află acolo unde wx + b = 0, ceea ce face ca rezultatul sigmoidei să fie exact 0,5. Alte praguri deplasează frontiera decizională fără a reantrena modelul.

Pierderea de entropie încrucișată binară

MSE poate fi calculată pentru o regresie logistică, dar nu este alegerea standard: împreună cu sigmoida poate crea un obiectiv neconvex și gradienți nefavorabili. Pentru modelul Bernoulli se folosește entropia încrucișată binară, numită și pierdere logaritmică:

Loss = -(1/n) * sum(y * log(p) + (1-y) * log(1-p))

De ce funcționează:

• Când y=1 și p este aproape de 1: log(1) = 0, deci pierderea este aproape de 0 — predicție corectă, cost mic
• Când y=1 și p este aproape de 0: log(0) tinde la minus infinit, deci pierderea este foarte mare — predicție greșită, cost mare
• Când y=0 și p este aproape de 0: log(1) = 0, deci pierderea este aproape de 0 — predicție corectă, cost mic
• Când y=0 și p este aproape de 1: log(0) tinde la minus infinit, deci pierderea este foarte mare — predicție greșită, cost mare

Pentru regresia logistică liniară, această pierdere este convexă în parametri, astfel încât nu are minime locale strict mai slabe decât minimul global.

Notă tehnică: Convexitatea nu garantează un singur minim finit. Obiectivul poate să nu fie strict convex, de exemplu când matricea caracteristicilor nu are rang complet, iar în cazul datelor perfect separabile pierderea logistică neregularizată își atinge infimul numai când norma ponderilor tinde la infinit. Regularizarea poate asigura o soluție finită și, în condiții adecvate, unică.

Coborârea pe gradient pentru regresia logistică

Gradienții entropiei încrucișate binare combinate cu sigmoida au o formă simplă:

dL/dw = (1/n) * sum((p - y) * x)
dL/db = (1/n) * sum(p - y)

Forma seamănă cu gradienții regresiei liniare. Diferența este că p = sigmoid(wx + b), nu p = wx + b. Sigmoida introduce neliniaritatea în probabilitate, în timp ce expresia gradientului față de parametrii liniari se simplifică în mod similar.

Frontiera de decizie

Pentru o intrare 2D, cu două caracteristici, frontiera de decizie la pragul 0,5 este dreapta pe care:

w1*x1 + w2*x2 + b = 0

Punctele de o parte sunt clasificate drept 1, iar cele de cealaltă parte drept 0. Regresia logistică pe caracteristicile originale produce o frontieră liniară. Dacă aveți nevoie de o frontieră curbă, puteți adăuga caracteristici polinomiale sau folosi un model neliniar; modelul rămâne liniar în caracteristicile transformate.

Clasificare cu mai multe clase prin softmax

Regresia logistică binară gestionează două clase. Pentru k clase, folosiți funcția softmax:

softmax(z_i) = e^(z_i) / sum(e^(z_j) pentru orice j)

Fiecare clasă are propriul vector de ponderi. Modelul calculează un scor z_i pentru fiecare clasă, iar softmax transformă scorurile în valori nenegative care însumează 1. Clasa prezisă este cea cu probabilitatea cea mai mare. Pentru stabilitate numerică, implementarea scade scorul maxim înainte de exponențiere.

Funcția de pierdere devine entropia încrucișată categorială:

Loss = -(1/n) * sum(sum(y_k * log(p_k)))

unde y_k este 1 pentru clasa adevărată și 0 pentru toate celelalte, conform codificării one-hot.

Metrici de evaluare

Acuratețea singură nu este suficientă. Pentru un set cu 95% exemple negative și 5% pozitive, un model care prezice întotdeauna clasa negativă obține o acuratețe de 95%, dar nu identifică niciun exemplu pozitiv.

Matrice de confuzie:

	Pozitiv prezis	Negativ prezis
Pozitiv în realitate	Adevărat pozitiv (TP)	Fals negativ (FN)
Negativ în realitate	Fals pozitiv (FP)	Adevărat negativ (TN)

Precizie: dintre toate exemplele prezise drept pozitive, câte sunt pozitive în realitate?

Precizie = TP / (TP + FP)

Rapel (sensibilitate): dintre toate exemplele pozitive în realitate, câte au fost detectate?

Rapel = TP / (TP + FN)

Scor F1: media armonică a preciziei și rapelului. Rezumă ambele metrici într-o singură valoare.

F1 = 2 * (Precizie * Rapel) / (Precizie + Rapel)

Când să acordați prioritate fiecărei metrici:

• Precizie: când falsurile pozitive sunt costisitoare, de exemplu într-un filtru de spam în care nu doriți să blocați mesaje legitime
• Rapel: când falsurile negative sunt costisitoare, de exemplu la screeningul oncologic, unde nu doriți să ratați o posibilă tumoare
• F1: când aveți nevoie de un singur rezumat al preciziei și rapelului și le considerați la fel de importante

Notă tehnică: Dacă nu există predicții pozitive, precizia are numitorul zero; dacă nu există exemple pozitive reale, rapelul este nedefinit. Implementarea didactică returnează 0 în aceste cazuri. În aplicații, stabiliți explicit convenția și raportați suportul fiecărei clase. Scorul F1 ignoră adevăratele negative și nu reprezintă automat costurile reale ale erorilor.

logistic-sigmoid

Construiți

Pasul 1: funcția sigmoidă și generarea datelor

import random
import math

def sigmoid(z):
    z = max(-500, min(500, z))
    return 1.0 / (1.0 + math.exp(-z))


random.seed(42)
N = 200
X = []
y = []

for _ in range(N // 2):
    X.append([random.gauss(2, 1), random.gauss(2, 1)])
    y.append(0)

for _ in range(N // 2):
    X.append([random.gauss(5, 1), random.gauss(5, 1)])
    y.append(1)

combined = list(zip(X, y))
random.shuffle(combined)
X, y = zip(*combined)
X = list(X)
y = list(y)

print(f"Generated {N} samples (2 classes, 2 features)")
print(f"Class 0 center: (2, 2), Class 1 center: (5, 5)")
print(f"First 5 samples:")
for i in range(5):
    print(f"  Features: [{X[i][0]:.2f}, {X[i][1]:.2f}], Label: {y[i]}")

Pasul 2: regresie logistică de la zero

class LogisticRegression:
    def __init__(self, n_features, learning_rate=0.01):
        self.weights = [0.0] * n_features
        self.bias = 0.0
        self.lr = learning_rate
        self.loss_history = []

    def predict_proba(self, x):
        z = sum(w * xi for w, xi in zip(self.weights, x)) + self.bias
        return sigmoid(z)

    def predict(self, x, threshold=0.5):
        return 1 if self.predict_proba(x) >= threshold else 0

    def compute_loss(self, X, y):
        n = len(y)
        total = 0.0
        for i in range(n):
            p = self.predict_proba(X[i])
            p = max(1e-15, min(1 - 1e-15, p))
            total += y[i] * math.log(p) + (1 - y[i]) * math.log(1 - p)
        return -total / n

    def fit(self, X, y, epochs=1000, print_every=200):
        n = len(y)
        n_features = len(X[0])
        for epoch in range(epochs):
            dw = [0.0] * n_features
            db = 0.0
            for i in range(n):
                p = self.predict_proba(X[i])
                error = p - y[i]
                for j in range(n_features):
                    dw[j] += error * X[i][j]
                db += error
            for j in range(n_features):
                self.weights[j] -= self.lr * (dw[j] / n)
            self.bias -= self.lr * (db / n)
            loss = self.compute_loss(X, y)
            self.loss_history.append(loss)
            if epoch % print_every == 0:
                print(f"  Epoch {epoch:4d} | Loss: {loss:.4f} | w: [{self.weights[0]:.3f}, {self.weights[1]:.3f}] | b: {self.bias:.3f}")
        return self

    def accuracy(self, X, y):
        correct = sum(1 for i in range(len(y)) if self.predict(X[i]) == y[i])
        return correct / len(y)


split = int(0.8 * N)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

print("\n=== Training Logistic Regression ===")
model = LogisticRegression(n_features=2, learning_rate=0.1)
model.fit(X_train, y_train, epochs=1000, print_every=200)

print(f"\nTrain accuracy: {model.accuracy(X_train, y_train):.4f}")
print(f"Test accuracy:  {model.accuracy(X_test, y_test):.4f}")
print(f"Weights: [{model.weights[0]:.4f}, {model.weights[1]:.4f}]")
print(f"Bias: {model.bias:.4f}")

Codul limitează z la intervalul [−500, 500] și p departe de 0 și 1 pentru a evita overflow-ul exponențial și log(0). Datele sunt amestecate înaintea separării, iar sămânța fixă face exemplul reproductibil. Implementarea nu include regularizare și nu verifică automat convergența; pe date perfect separabile, ponderile pot continua să crească deși acuratețea s-a stabilizat.

Pasul 3: matrice de confuzie și metrici de la zero

class ClassificationMetrics:
    def __init__(self, y_true, y_pred):
        self.tp = sum(1 for t, p in zip(y_true, y_pred) if t == 1 and p == 1)
        self.tn = sum(1 for t, p in zip(y_true, y_pred) if t == 0 and p == 0)
        self.fp = sum(1 for t, p in zip(y_true, y_pred) if t == 0 and p == 1)
        self.fn = sum(1 for t, p in zip(y_true, y_pred) if t == 1 and p == 0)

    def accuracy(self):
        total = self.tp + self.tn + self.fp + self.fn
        return (self.tp + self.tn) / total if total > 0 else 0

    def precision(self):
        denom = self.tp + self.fp
        return self.tp / denom if denom > 0 else 0

    def recall(self):
        denom = self.tp + self.fn
        return self.tp / denom if denom > 0 else 0

    def f1(self):
        p = self.precision()
        r = self.recall()
        return 2 * p * r / (p + r) if (p + r) > 0 else 0

    def print_confusion_matrix(self):
        print(f"\n  Confusion Matrix:")
        print(f"                  Predicted")
        print(f"                  Pos   Neg")
        print(f"  Actual Pos     {self.tp:4d}  {self.fn:4d}")
        print(f"  Actual Neg     {self.fp:4d}  {self.tn:4d}")

    def print_report(self):
        self.print_confusion_matrix()
        print(f"\n  Accuracy:  {self.accuracy():.4f}")
        print(f"  Precision: {self.precision():.4f}")
        print(f"  Recall:    {self.recall():.4f}")
        print(f"  F1 Score:  {self.f1():.4f}")


y_pred_test = [model.predict(x) for x in X_test]
print("\n=== Classification Report (Test Set) ===")
metrics = ClassificationMetrics(y_test, y_pred_test)
metrics.print_report()

Pasul 4: analiza frontierei de decizie

print("\n=== Decision Boundary ===")
w1, w2 = model.weights
b = model.bias
print(f"Decision boundary: {w1:.4f}*x1 + {w2:.4f}*x2 + {b:.4f} = 0")
if abs(w2) > 1e-10:
    print(f"Solved for x2:     x2 = {-w1/w2:.4f}*x1 + {-b/w2:.4f}")

print("\nSample predictions near the boundary:")
test_points = [
    [3.0, 3.0],
    [3.5, 3.5],
    [4.0, 4.0],
    [2.5, 2.5],
    [5.0, 5.0],
]
for point in test_points:
    prob = model.predict_proba(point)
    pred = model.predict(point)
    print(f"  [{point[0]}, {point[1]}] -> prob={prob:.4f}, class={pred}")

Pasul 5: clasificare cu mai multe clase prin softmax

class SoftmaxRegression:
    def __init__(self, n_features, n_classes, learning_rate=0.01):
        self.n_features = n_features
        self.n_classes = n_classes
        self.lr = learning_rate
        self.weights = [[0.0] * n_features for _ in range(n_classes)]
        self.biases = [0.0] * n_classes

    def softmax(self, scores):
        max_score = max(scores)
        exp_scores = [math.exp(s - max_score) for s in scores]
        total = sum(exp_scores)
        return [e / total for e in exp_scores]

    def predict_proba(self, x):
        scores = [
            sum(self.weights[k][j] * x[j] for j in range(self.n_features)) + self.biases[k]
            for k in range(self.n_classes)
        ]
        return self.softmax(scores)

    def predict(self, x):
        probs = self.predict_proba(x)
        return probs.index(max(probs))

    def fit(self, X, y, epochs=1000, print_every=200):
        n = len(y)
        for epoch in range(epochs):
            grad_w = [[0.0] * self.n_features for _ in range(self.n_classes)]
            grad_b = [0.0] * self.n_classes
            total_loss = 0.0
            for i in range(n):
                probs = self.predict_proba(X[i])
                for k in range(self.n_classes):
                    target = 1.0 if y[i] == k else 0.0
                    error = probs[k] - target
                    for j in range(self.n_features):
                        grad_w[k][j] += error * X[i][j]
                    grad_b[k] += error
                true_prob = max(probs[y[i]], 1e-15)
                total_loss -= math.log(true_prob)
            for k in range(self.n_classes):
                for j in range(self.n_features):
                    self.weights[k][j] -= self.lr * (grad_w[k][j] / n)
                self.biases[k] -= self.lr * (grad_b[k] / n)
            if epoch % print_every == 0:
                print(f"  Epoch {epoch:4d} | Loss: {total_loss / n:.4f}")
        return self

    def accuracy(self, X, y):
        correct = sum(1 for i in range(len(y)) if self.predict(X[i]) == y[i])
        return correct / len(y)


random.seed(42)
X_3class = []
y_3class = []

centers = [(1, 1), (5, 1), (3, 5)]
for label, (cx, cy) in enumerate(centers):
    for _ in range(50):
        X_3class.append([random.gauss(cx, 0.8), random.gauss(cy, 0.8)])
        y_3class.append(label)

combined = list(zip(X_3class, y_3class))
random.shuffle(combined)
X_3class, y_3class = zip(*combined)
X_3class = list(X_3class)
y_3class = list(y_3class)

split_3 = int(0.8 * len(X_3class))
X_train_3 = X_3class[:split_3]
y_train_3 = y_3class[:split_3]
X_test_3 = X_3class[split_3:]
y_test_3 = y_3class[split_3:]

print("\n=== Multi-class Softmax Regression (3 classes) ===")
softmax_model = SoftmaxRegression(n_features=2, n_classes=3, learning_rate=0.1)
softmax_model.fit(X_train_3, y_train_3, epochs=1000, print_every=200)
print(f"\nTrain accuracy: {softmax_model.accuracy(X_train_3, y_train_3):.4f}")
print(f"Test accuracy:  {softmax_model.accuracy(X_test_3, y_test_3):.4f}")

print("\nSample predictions:")
for i in range(5):
    probs = softmax_model.predict_proba(X_test_3[i])
    pred = softmax_model.predict(X_test_3[i])
    print(f"  True: {y_test_3[i]}, Predicted: {pred}, Probs: [{', '.join(f'{p:.3f}' for p in probs)}]")

Pasul 6: reglarea pragului

print("\n=== Threshold Tuning ===")
print("Default threshold: 0.5. Adjusting the threshold trades precision for recall.\n")

thresholds = [0.3, 0.4, 0.5, 0.6, 0.7]
print(f"{'Threshold':>10} {'Accuracy':>10} {'Precision':>10} {'Recall':>10} {'F1':>10}")
print("-" * 52)

for t in thresholds:
    y_pred_t = [1 if model.predict_proba(x) >= t else 0 for x in X_test]
    m = ClassificationMetrics(y_test, y_pred_t)
    print(f"{t:>10.1f} {m.accuracy():>10.4f} {m.precision():>10.4f} {m.recall():>10.4f} {m.f1():>10.4f}")

Reducerea pragului clasifică mai multe exemple drept pozitive și tinde să crească rapelul cu prețul preciziei; creșterea pragului tinde să aibă efectul opus. Pragul 0,5 nu este universal optim: alegerea depinde de calibrare, prevalență, costurile erorilor și metrica operațională.

Notă tehnică: Codul compară pragurile direct pe X_test și y_test. Folosiți această buclă pe un set de validare pentru a alege pragul, apoi evaluați o singură dată alegerea pe setul de testare; altfel, estimarea finală este influențată de test.

Folosiți

Acum implementați același flux cu scikit-learn.

from sklearn.linear_model import LogisticRegression as SklearnLR
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import numpy as np

np.random.seed(42)
X_0 = np.random.randn(100, 2) + [2, 2]
X_1 = np.random.randn(100, 2) + [5, 5]
X_sk = np.vstack([X_0, X_1])
y_sk = np.array([0] * 100 + [1] * 100)

X_tr, X_te, y_tr, y_te = train_test_split(X_sk, y_sk, test_size=0.2, random_state=42)

scaler = StandardScaler()
X_tr_sc = scaler.fit_transform(X_tr)
X_te_sc = scaler.transform(X_te)

lr = SklearnLR()
lr.fit(X_tr_sc, y_tr)
y_pred = lr.predict(X_te_sc)

print("=== Scikit-learn Logistic Regression ===")
print(f"Accuracy:  {accuracy_score(y_te, y_pred):.4f}")
print(f"Precision: {precision_score(y_te, y_pred):.4f}")
print(f"Recall:    {recall_score(y_te, y_pred):.4f}")
print(f"F1:        {f1_score(y_te, y_pred):.4f}")
print(f"\nConfusion Matrix:\n{confusion_matrix(y_te, y_pred)}")
print(f"\nClassification Report:\n{classification_report(y_te, y_pred)}")

Implementarea de la zero și cea din scikit-learn urmează același model liniar logistic și pot produce frontiere și metrici similare pe aceste date, dar nu sunt matematic identice în configurația prezentată. scikit-learn adaugă solvere precum liblinear, lbfgs și saga, regularizare implicită și optimizări de stabilitate numerică. În versiunile actuale, pentru clasificare cu mai multe clase, toate solvere în afară de liblinear optimizează pierderea multinomială; liblinear necesită înfășurarea explicită în OneVsRestClassifier.

Notă tehnică a traducerii: formularea sursei despre selectarea automată a strategiei one-vs-rest nu mai descrie versiunile actuale ale scikit-learn. SklearnLR() aplică regularizare în configurația implicită, în timp ce clasa didactică nu o face. De asemenea, exemplul nu folosește stratify=y_sk la împărțire; pentru seturi dezechilibrate, stratificarea ajută la păstrarea proporțiilor claselor.

Livrați

Această lecție produce:

• code/logistic_regression.py — regresie logistică de la zero, cu metrici

Exerciții

1. Generați un set de date care NU este separabil liniar, de exemplu două cercuri concentrice. Antrenați regresia logistică și observați limitarea ei. Apoi adăugați caracteristici polinomiale, x1^2, x2^2 și x1*x2, și antrenați din nou. Arătați cum se îmbunătățește acuratețea pe un set de evaluare independent.
2. Implementați o matrice de confuzie multiclasă pentru modelul softmax cu trei clase. Calculați precizia și rapelul pentru fiecare clasă. Care clasă este cel mai greu de clasificat?
3. Construiți de la zero o curbă ROC. Pentru 100 de praguri între 0 și 1, calculați rata adevăratelor pozitive și rata falselor pozitive. Calculați AUC, aria de sub curbă, prin regula trapezelor. Folosiți date de validare pentru alegerea pragului și păstrați setul de testare pentru evaluarea finală.

Termeni-cheie

Termen	Cum i se spune	Ce înseamnă de fapt
Regresie logistică	„Regresie pentru clasificare”	Model liniar urmat de o funcție sigmoidă, antrenat pentru probabilități condiționate de clasă
Funcție sigmoidă	„Curba în S”	Funcția 1/(1+e^(-z)), care transformă orice număr real într-o valoare din intervalul (0, 1)
Entropie încrucișată binară	„Pierdere logaritmică”	Pierderea -[y*log(p) + (1-y)*log(1-p)], care penalizează sever predicțiile greșite făcute cu încredere
Frontieră de decizie	„Linia despărțitoare”	Suprafața pe care probabilitatea modelului este egală cu pragul ales; la pragul 0,5, wx+b=0
Softmax	„Sigmoidă multiclasă”	Funcție care transformă un vector de scoruri în valori nenegative cu sumă egală cu 1
Precizie	„Câte dintre cele selectate sunt relevante”	TP / (TP + FP), proporția predicțiilor pozitive care sunt într-adevăr pozitive
Rapel	„Câte dintre cele relevante sunt selectate”	TP / (TP + FN), proporția exemplelor pozitive reale identificate corect de model
Scor F1	„Acuratețe echilibrată”	Media armonică a preciziei și rapelului: 2PR / (P+R); nu este același lucru cu balanced accuracy
Matrice de confuzie	„Defalcarea erorilor”	Tabel care prezintă numărul de TP, TN, FP și FN pentru perechile de clase
Prag	„Valoarea-limită”	Valoarea probabilității peste care modelul prezice clasa 1; 0,5 este implicită adesea, dar poate fi reglată
Codificare one-hot	„Coloane binare pentru categorii”	Reprezentarea clasei k printr-un vector de zerouri cu 1 pe poziția k
Entropie încrucișată categorială	„Pierdere logaritmică multiclasă”	Extinderea entropiei încrucișate binare la k clase, folosind etichete codificate one-hot

Notă tehnică: Formula „balanced accuracy” din formularea colocvială a sursei pentru F1 poate induce în eroare. În metricile standard, balanced accuracy este media rapelului pe clase și diferă de F1.

---

Sursă: Logistic Regression — original

Navigare: înapoi: 02.02 — Regresie liniară · Faza 2 — Bazele învățării automate · Catalog complet · în continuare: 02.04 — Arbori de decizie și păduri aleatoare.