Umgang mit Datennormalisierungsausnahmen in der C++-Entwicklung

So gehen Sie mit Datennormalisierungsausnahmen in der C++-Entwicklung um

Übersicht:

In der C++-Entwicklung ist die Datennormalisierung eine häufig verwendete Datenverarbeitungstechnologie, die die Daten innerhalb einer bestimmten Bereichsverteilung ausgleichen kann, um die Modellleistung zu verbessern. Bei der Datennormalisierung treten jedoch manchmal ungewöhnliche Situationen auf, z. B. eine zu konzentrierte Datenverteilung oder zu große Ausreißer, was zu schlechten Normalisierungsergebnissen führt. In diesem Artikel wird der Umgang mit Datennormalisierungsausnahmen in der C++-Entwicklung vorgestellt.

1. Grundprinzipien der Datennormalisierung

Zu den gängigen Normalisierungsmethoden gehören lineare Normalisierung, Z-Score-Normalisierung, Regularisierung usw. Unter diesen ist die lineare Normalisierung die am häufigsten verwendete Methode, die die Daten auf den Bereich von [0, 1] skaliert. Der Code zum Implementieren der linearen Normalisierung lautet wie folgt:

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

2. Analyse abnormaler Datennormalisierungsprobleme

Wenn die Datenverteilung in einem bestimmten Intervall verzerrt oder zu konzentriert ist, kann die Verwendung der linearen Normalisierung zu einer Normalisierung führen. Die einheitliche Datenverteilung ist ungleichmäßig und kann nicht die erwarteten Ergebnisse erzielen. Wenn der Datensatz außerdem Ausreißer enthält, wirkt sich dies zusätzlich auf die Normalisierungsergebnisse aus.

Zum Beispiel für den folgenden Datensatz:

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

Das Ergebnis nach Verwendung der linearen Normalisierung ist:

{0, 0,011 , 0,022, 0,033, 0,044, 0,055, 0,066, 0,077, 0,088, 1}

Es ist ersichtlich, dass aufgrund des Vorhandenseins des Ausreißers 100 andere Daten zu stark zwischen [0, 1] konzentriert sind und 100 weit entfernt ist aus anderen Daten.

3. Methoden zum Umgang mit Datennormalisierungsanomalien

1. Quantilbasierte Normalisierungsmethode

Um das Problem von Ausreißern im Datensatz zu lösen, kann die quantilbasierte Normalisierungsmethode verwendet werden. Diese Methode entfernt zunächst Ausreißer im Datensatz und normalisiert sie anschließend. Die spezifischen Schritte sind wie folgt:

(1) Berechnen Sie das obere Quartil (Q3) und das untere Quartil (Q1) des Datensatzes.

(2) Berechnen Sie den inneren Abstand (IQR) des Datensatzes, d. h. IQR = Q3 - Q1.

(3) Entfernen Sie gemäß der obigen Formel Ausreißer aus dem Datensatz, die kleiner als Q1-1,5IQR und größer als Q3+1,5IQR sind.

(4) Lineare Normalisierung der Daten nach Entfernung von Ausreißern.

Der Referenzcode lautet wie folgt:

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. Nichtlineare Normalisierungsmethode

Zusätzlich zur linearen Normalisierung können Sie auch versuchen, nichtlineare Normalisierungsmethoden wie logarithmische Normalisierung oder exponentielle Normalisierung zu verwenden. Diese Methoden können die Daten nichtlinear skalieren, um sie besser an die Verteilungseigenschaften der Daten anzupassen.

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

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

4. Beispielanwendung

Das Folgende ist eine Beispielanwendung, die die quantilbasierte Normalisierungsmethode verwendet.

#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;
}

Die Ausgabeergebnisse sind wie folgt:

Originaldaten:
1 2 3 4 5 6 7 8 9 100
Normalisierte Daten:
0,000805859 0,00161172 0,00241759 0,00322345. 0,00 402931 0,00483516 0,00564102 0,00644688 0,00725273 0,99838

Das können Sie nach dem Quantil sehen Durch die Normalisierung erhält man ein normalisiertes Ergebnis, das besser zur Datenverteilung passt.

Das obige ist der detaillierte Inhalt vonUmgang mit Datennormalisierungsausnahmen in der C++-Entwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!