Cara menangani pengecualian normalisasi data dalam pembangunan C++

Cara menangani pengecualian penormalan data dalam pembangunan C++

Ikhtisar:

Dalam pembangunan C++, penormalan data ialah teknologi pemprosesan data yang biasa digunakan, yang boleh mengimbangi data dalam taburan julat tertentu untuk meningkatkan prestasi model. Walau bagaimanapun, kadangkala situasi tidak normal ditemui semasa normalisasi data, seperti taburan data terlalu pekat atau outlier terlalu besar, mengakibatkan hasil normalisasi yang lemah. Artikel ini akan memperkenalkan cara menangani pengecualian normalisasi data dalam pembangunan C++.

1. Prinsip asas penormalan data

Penormalan data ialah untuk memetakan data kepada julat yang ditentukan termasuk penormalan linear, penormalan skor Z, penormalan, dsb. Antaranya, normalisasi linear ialah kaedah yang paling biasa digunakan, yang menskalakan data kepada julat [0, 1]. Kod untuk melaksanakan pelaziman linear adalah seperti berikut:

double linear_normalize(double x, double min_value, double max_value) {
    return (x - min_value) / (max_value - min_value);
}

2. Analisis masalah normalisasi data tidak normal

Apabila taburan data condong atau terlalu tertumpu dalam selang tertentu, menggunakan normalisasi linear boleh menyebabkan normalisasi Taburan data bersatu adalah tidak sekata dan tidak dapat mencapai hasil yang diharapkan. Selain itu, jika terdapat outlier dalam set data, ia akan menjejaskan lagi hasil normalisasi.

Sebagai contoh, untuk set data berikut:

{1, 2, 3, 4, 5, 6, 7, 8, 9, 100}

Hasil selepas menggunakan normalisasi linear ialah:

{0, 0.011 , 0.022, 0.033, 0.044, 0.055, 0.066, 0.077, 0.088, 1}

Dapat dilihat bahawa disebabkan kehadiran outlier 100, data lain terlalu tertumpu antara [0, 101], manakala jauh daripada data lain.

3. Kaedah menangani anomali normalisasi data

1. Kaedah normalisasi berasaskan kuantil

Untuk menyelesaikan masalah outlier dalam set data, kaedah normalisasi berasaskan kuantil boleh digunakan. Kaedah ini mula-mula mengalih keluar outlier dalam set data dan kemudian menormalkannya. Langkah-langkah khusus adalah seperti berikut:

(1) Kira kuartil atas (Q3) dan kuartil bawah (Q1) set data.

(2) Kira jarak dalam (IQR) set data, iaitu IQR = Q3 - Q1.

(3) Mengikut formula di atas, keluarkan outlier daripada set data yang kurang daripada Q1-1.5IQR dan lebih besar daripada Q3+1.5IQR.

(4) Linear menormalkan data selepas mengalih keluar outlier.

Kod rujukan adalah seperti berikut:

vector<double> quantile_normalize(vector<double> data) {
    sort(data.begin(), data.end());
    int n = data.size();
    double q1 = data[(n - 1) / 4];
    double q3 = data[(3 * (n - 1)) / 4];
    double iqr = q3 - q1;
    
    vector<double> normalized_data;
    for (double x : data) {
        if (x < q1 - 1.5 * iqr || x > q3 + 1.5 * iqr) {
            continue;
        }
        double normalized_x = linear_normalize(x, q1 - 1.5 * iqr, q3 + 1.5 * iqr);
        normalized_data.push_back(normalized_x);
    }
    
    return normalized_data;
}

2. Kaedah penormalan tak linear

Selain penormalan linear, anda juga boleh cuba menggunakan kaedah penormalan tak linear, seperti penormalan logaritma atau penormalan eksponen. Kaedah ini boleh menskalakan data secara tidak linear untuk menyesuaikan diri dengan ciri pengedaran data dengan lebih baik.

double log_normalize(double x, double base) {
    return log(x) / log(base);
}

double exp_normalize(double x, double base) {
    return pow(base, x);
}

4. Contoh aplikasi

Berikut adalah contoh aplikasi menggunakan kaedah normalisasi berasaskan kuantil.

#include 
#include 
#include 

using namespace std;

double linear_normalize(double x, double min_value, double max_value) {
    return (x - min_value) / (max_value - min_value);
}

vector<double> quantile_normalize(vector<double> data) {
    sort(data.begin(), data.end());
    int n = data.size();
    double q1 = data[(n - 1) / 4];
    double q3 = data[(3 * (n - 1)) / 4];
    double iqr = q3 - q1;
    
    vector<double> normalized_data;
    for (double x : data) {
        if (x < q1 - 1.5 * iqr || x > q3 + 1.5 * iqr) {
            continue;
        }
        double normalized_x = linear_normalize(x, q1 - 1.5 * iqr, q3 + 1.5 * iqr);
        normalized_data.push_back(normalized_x);
    }
    
    return normalized_data;
}

int main() {
    vector data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 100};
    vector normalized_data = quantile_normalize(data);
    
    cout << "原始数据：" << endl;
    for (double x : data) {
        cout << x << " ";
    }
    cout << endl;
    
    cout << "归一化后的数据：" << endl;
    for (double x : normalized_data) {
        cout << x << " ";
    }
    cout << endl;
    
    return 0;
}

Hasil keluaran adalah seperti berikut:

Data asal:
1 2 3 4 5 6 7 8 9 100
Data ternormal:
0.000805859 0.0016102.00161172 0402931 0.00483516 0.00564102 0.00644688 0.00725273 0.99838

Anda boleh melihatnya selepas Selepas kuantil normalisasi, keputusan ternormal yang lebih sesuai untuk taburan data diperolehi.

Atas ialah kandungan terperinci Cara menangani pengecualian normalisasi data dalam pembangunan C++. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!