Genel Bakış

metrics modülü, makine öğrenmesi modellerinin performansını değerlendirmek için yaygın kullanılan metrikleri sağlar.

Classification Metrics

kullan ai/metrics;

değişken y_true = [0, 1, 1, 0, 1, 0];
değişken y_pred = [0, 1, 0, 0, 1, 0];

değişken acc = accuracy(y_true, y_pred);
yazdir("Doğruluk: {:.2f}%", acc * 100.0);
// Çıktı: Doğruluk: 83.33%

kullan ai/metrics;

değişken precision = precision_score(y_true, y_pred);
değişken recall = recall_score(y_true, y_pred);
değişken f1 = f1_score(y_true, y_pred);

yazdir("Precision: {:.4f}", precision);
yazdir("Recall: {:.4f}", recall);
yazdir("F1 Score: {:.4f}", f1);

kullan ai/metrics;

değişken cm = confusion_matrix(y_true, y_pred, num_classes: 2);

yazdir("Confusion Matrix:");
yazdir("{:?}", cm);
// [[TP, FP],
//  [FN, TN]]

// Sınıf bazında metrikler
her i içinde aralık(num_classes) için yap
    değişken precision_i = cm[i][i] / cm[i].topla();
    değişken recall_i = cm[i][i] / cm.column(i).topla();
    yazdir("Sınıf {}: P={:.3f}, R={:.3f}", i, precision_i, recall_i);
son

kullan ai/metrics;

// Probability tahminleri
değişken y_true = [0, 0, 1, 1];
değişken y_proba = [0.1, 0.4, 0.35, 0.8];

değişken auc = roc_auc_score(y_true, y_proba);
yazdir("ROC-AUC: {:.4f}", auc);

// ROC curve çizimi
değişken (fpr, tpr, thresholds) = roc_curve(y_true, y_proba);
plot_roc_curve(fpr, tpr, auc);

Multi-Class Metrics

kullan ai/metrics;

değişken y_true = [0, 1, 2, 0, 1, 2];
değişken y_pred = [0, 2, 1, 0, 0, 1];

// Macro average (her sınıf eşit ağırlık)
değişken f1_macro = f1_score(y_true, y_pred, average: "macro");

// Micro average (tüm örnekler eşit)
değişken f1_micro = f1_score(y_true, y_pred, average: "micro");

// Weighted (sınıf dağılımına göre)
değişken f1_weighted = f1_score(y_true, y_pred, average: "weighted");

yazdir("F1 Macro: {:.4f}", f1_macro);
yazdir("F1 Micro: {:.4f}", f1_micro);
yazdir("F1 Weighted: {:.4f}", f1_weighted);

kullan ai/metrics;

değişken report = classification_report(
    y_true,
    y_pred,
    target_names: ["Kedi", "Köpek", "Kuş"]
);

yazdir!("{}", report);
// Çıktı:
//              precision  recall  f1-score  support
//
//        Kedi      0.83    0.71     0.77       14
//       Köpek      0.75    0.90     0.82       20
//        Kuş      0.88    0.84     0.86       19
//
//     accuracy                      0.81       53
//    macro avg      0.82    0.82     0.82       53
// weighted avg      0.81    0.81     0.81       53

Regression Metrics

kullan ai/metrics;

değişken y_true = [3.0, -0.5, 2.0, 7.0];
değişken y_pred = [2.5, 0.0, 2.1, 7.8];

değişken mse = mean_squared_error(y_true, y_pred);
değişken rmse = mse.sqrt();
değişken mae = mean_absolute_error(y_true, y_pred);

yazdir("MSE: {:.4f}", mse);
yazdir("RMSE: {:.4f}", rmse);
yazdir("MAE: {:.4f}", mae);

kullan ai/metrics;

değişken r2 = r2_score(y_true, y_pred);
yazdir("R² Score: {:.4f}", r2);

// Adjusted R² (feature sayısı ile)
değişken r2_adj = adjusted_r2_score(y_true, y_pred, n_features: 5);
yazdir("Adjusted R²: {:.4f}", r2_adj);

Loss Functions

kullan ai/metrics;

// Binary cross-entropy
değişken y_true = Tensor::yeni([1.0, 0.0, 1.0]);
değişken y_pred = Tensor::yeni([0.9, 0.1, 0.8]);

değişken bce = binary_cross_entropy(y_pred, y_true);
yazdir("BCE Loss: {:.4f}", bce);

// Categorical cross-entropy
değişken y_true_cat = Tensor::yeni([[0., 1., 0.], [1., 0., 0.]]);
değişken y_pred_cat = Tensor::yeni([[0.1, 0.8, 0.1], [0.9, 0.05, 0.05]]);

değişken cce = categorical_cross_entropy(y_pred_cat, y_true_cat);
yazdir("CCE Loss: {:.4f}", cce);

kullan ai/metrics;

// Imbalanced dataset için
değişken focal = focal_loss(
    y_pred,
    y_true,
    alpha: 0.25,  // Pozitif sınıf ağırlığı
    gamma: 2.0    // Focusing parameter
);
yazdir("Focal Loss: {:.4f}", focal);

Custom Metrics

kullan ai/metrics;

fonksiyon custom_accuracy(y_true: Tensor, y_pred: Tensor) -> ondalık yap
    değişken threshold = 0.7;
    değişken high_conf_mask = y_pred.gt(threshold);
    değişken correct = y_true.eq(y_pred.round()).ve(high_conf_mask);
    
    dön correct.topla() as ondalık / y_true.len() as ondalık;
son

// Kullanım
değişken acc = custom_accuracy(y_true, y_pred);
yazdir("High-confidence accuracy: {:.2f}%", acc * 100.0);

Batch Evaluation

kullan ai/metrics;
kullan ai/train;

fonksiyon evaluate(model: Model, test_loader: DataLoader) -> Metrics yap
    model.değerlendirme();
    
    değişken tüm_preds = [];
    değişken tüm_targets = [];
    
    her (x, y) içinde test_loader için yap
        değişken pred = model.ileri(x);
        tüm_preds.extend(pred.argmax(dim: 1));
        tüm_targets.extend(y);
    son
    
    dön Metrics {
        accuracy: accuracy(tüm_targets, tüm_preds),
        f1: f1_score(tüm_targets, tüm_preds, average: "weighted"),
        precision: precision_score(tüm_targets, tüm_preds, average: "weighted"),
        recall: recall_score(tüm_targets, tüm_preds, average: "weighted")
    };
son

API Referansı