Comment gérer les exceptions de normalisation des données dans le développement C++

Comment gérer les exceptions de normalisation des données dans le développement C++

Présentation :

Dans le développement C++, la normalisation des données est une technologie de traitement de données couramment utilisée, qui peut équilibrer les données dans une certaine plage de distribution pour améliorer les performances du modèle. Cependant, des situations anormales surviennent parfois lors de la normalisation des données, telles que la distribution des données est trop concentrée ou les valeurs aberrantes sont trop importantes, ce qui entraîne de mauvais résultats de normalisation. Cet article explique comment gérer les exceptions de normalisation des données dans le développement C++.

1. Principes de base de la normalisation des données

La normalisation des données consiste à mapper les données sur une plage spécifiée. Les méthodes de normalisation courantes incluent la normalisation linéaire, la normalisation du score Z, la régularisation, etc. Parmi elles, la normalisation linéaire est la méthode la plus couramment utilisée, qui met à l'échelle les données dans la plage de [0, 1]. Le code pour implémenter la normalisation linéaire est le suivant :

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

2. Analyse des problèmes anormaux de normalisation des données

Lorsque la distribution des données est asymétrique ou trop concentrée dans un certain intervalle, l'utilisation de la normalisation linéaire peut entraîner une normalisation La distribution unifiée des données est inégale et ne peut pas atteindre les résultats escomptés. De plus, s’il existe des valeurs aberrantes dans l’ensemble de données, cela affectera davantage les résultats de normalisation.

Par exemple, pour l'ensemble de données suivant :

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

Le résultat après utilisation de la normalisation linéaire est :

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

On peut voir qu'en raison de la présence de la valeur aberrante 100, les autres données sont trop concentrées entre [0, 1], alors que 100 est loin à partir d'autres données.

3. Méthodes de traitement des anomalies de normalisation des données

1. Méthode de normalisation basée sur les quantiles

Afin de résoudre le problème des valeurs aberrantes dans l'ensemble de données, la méthode de normalisation basée sur les quantiles peut être utilisée. Cette méthode supprime d'abord les valeurs aberrantes dans l'ensemble de données, puis les normalise. Les étapes spécifiques sont les suivantes :

(1) Calculez le quartile supérieur (Q3) et le quartile inférieur (Q1) de l'ensemble de données.

(2) Calculez la distance intérieure (IQR) de l'ensemble de données, c'est-à-dire IQR = Q3 - Q1.

(3) Selon la formule ci-dessus, supprimez les valeurs aberrantes de l'ensemble de données qui sont inférieures à Q1-1,5IQR et supérieures à Q3+1,5IQR.

(4) Normaliser linéairement les données après avoir supprimé les valeurs aberrantes.

Le code de référence est le suivant :

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. Méthode de normalisation non linéaire

En plus de la normalisation linéaire, vous pouvez également essayer d'utiliser des méthodes de normalisation non linéaire, telles que la normalisation logarithmique ou la normalisation exponentielle. Ces méthodes peuvent mettre à l'échelle les données de manière non linéaire pour mieux s'adapter aux caractéristiques de distribution des données.

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

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

4. Exemple d'application

Ce qui suit est un exemple d'application utilisant la méthode de normalisation basée sur les quantiles.

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

Les résultats de sortie sont les suivants :

Données originales :
1 2 3 4 5 6 7 8 9 100
Données normalisées :
0,000805859 0,00161172 0,00241759 0,00322345 0,00 402931 0,00483516 0,00564102 0,00644688 0,00725273 0,99838

Vous pouvez le voir après Après le quantile normalisation, un résultat normalisé plus adapté à la distribution des données est obtenu.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!