1. Introduction

Conception et optimisation d'hypercubes latins multidimensionnels

2. Environnement logiciel

2.1 matlab

3. Processus principal

3.1 Conception d'hypercube latin

Une conception d'hypercube latin est une méthode utilisée dans la conception expérimentale et l'optimisation pour garantir que les points d'échantillonnage sont uniformément répartis à différents niveaux de plusieurs variables. Son idée de base est de diviser l'espace d'échantillonnage en sous-régions uniformes, puis de sélectionner un point d'échantillonnage dans chaque sous-région.

% 设置变量范围和样本数量
rangeX = [0 1]; % X 变量范围
rangeY = [0 1]; % Y 变量范围
numSamples = 20; % 样本数量

% 生成二维拉丁超立方设计
design = lhsdesign(numSamples, 2);

% 将设计映射到指定的变量范围
samplesX = design(:, 1) * (rangeX(2) - rangeX(1)) + rangeX(1);
samplesY = design(:, 2) * (rangeY(2) - rangeY(1)) + rangeY(1);

% 绘制二维图
scatter(samplesX, samplesY, 'filled');
xlabel('X');
ylabel('Y');
title('Latin Hypercube Design (2D)');

3.2 Conception stochastique optimale d'hypercube latin ROLHD

L'optimisation aléatoire de la conception de l'hypercube latin (ROLHD) est une méthode d'optimisation de la conception de l'hypercube latin. Il améliore la conception originale de l'hypercube latin en introduisant un algorithme d'optimisation aléatoire et stochastique pour augmenter l'uniformité et la discrétion des points d'échantillonnage.

1 L'idée de base de la méthode ROLHD est la suivante :

2 Générez une conception initiale d'hypercube latin.

3 La conception initiale est améliorée à l'aide d'un algorithme d'optimisation stochastique.

4 Dans chaque itération d'optimisation, une perturbation aléatoire ou une opération d'optimisation est effectuée sur la conception actuelle.

5 Évaluez la qualité de la nouvelle conception selon un certain indice d'évaluation (comme la distance maximale et minimale, la variance, etc.).

6 Si la nouvelle conception est meilleure que la conception actuelle, acceptez la nouvelle conception comme conception optimale actuelle ; sinon, conservez la conception actuelle.

Répétez les étapes 3 à 5 jusqu'à ce que le nombre d'itérations spécifié soit atteint ou que la condition d'arrêt soit remplie.

% 设置变量范围和样本数量
rangeX = [0 1]; % X 变量范围
rangeY = [0 1]; % Y 变量范围
numSamples = 20; % 样本数量

% 迭代改进型拉丁超立方设计 (ROLHD)
numIterations = 100; % 迭代次数
bestDesign = lhsdesign(numSamples, 2); % 初始的拉丁超立方设计
bestCriterion = computeCriterion(bestDesign); % 计算初始设计的准则值

for iteration = 1:numIterations
    % 生成随机变换
    transformedDesign = applyRandomTransform(bestDesign);
    
    % 计算变换后的设计的准则值
    transformedCriterion = computeCriterion(transformedDesign);
    
    % 比较新旧设计的准则值，更新当前最优设计
    if transformedCriterion < bestCriterion
        bestDesign = transformedDesign;
        bestCriterion = transformedCriterion;
    end
end

% 将设计映射到指定的变量范围
samplesX = bestDesign(:, 1) * (rangeX(2) - rangeX(1)) + rangeX(1);
samplesY = bestDesign(:, 2) * (rangeY(2) - rangeY(1)) + rangeY(1);

% 绘制二维图
scatter(samplesX, samplesY, 'filled');
xlabel('X');
ylabel('Y');
title('Optimized Latin Hypercube Design');

% 计算设计的准则值（示例中使用随机值作为准则值，实际应根据具体问题定义准则）
function criterion = computeCriterion(design)
    criterion = rand(); % 使用随机值作为准则值，实际应根据具体问题定义准则
end

% 应用随机变换（示例中使用随机排序作为变换，实际应根据具体问题定义变换）
function transformedDesign = applyRandomTransform(design)
    transformedDesign = design(randperm(size(design, 1)), :);
end

3.3 Optimisation de la génération de distance maximale et minimale

La distance minimale maximale est une méthode d'optimisation pour améliorer les conceptions d'hypercubes latins. Son objectif est de maximiser la distance minimale entre les points d'échantillonnage pour augmenter la discrétion et l'uniformité entre les points d'échantillonnage.

Voici l'idée de base de l'optimisation de la génération de la méthode de distance maximale et minimale :

1 Tout d'abord, générez une conception initiale d'hypercube latin.

2 Calculez la distance minimale entre les points d'échantillonnage dans la conception initiale.

3 itérations d'optimisation sont effectuées, chaque itération générant un nouveau design et calculant la distance minimale.

4 À chaque itération, pour chaque point d'échantillonnage, un nouvel emplacement est généré par réaffectation aléatoire. Cela peut être fait en échangeant les positions des deux points d'échantillonnage ou en choisissant au hasard une nouvelle position dans la plage des points d'échantillonnage.

5 Calculez la distance minimale entre les points d'échantillonnage dans le nouveau plan.

6 Si la distance minimale de la nouvelle conception est meilleure que celle de la conception précédente, acceptez cette conception comme la conception optimale actuelle ; sinon, conservez la conception précédente.

Répétez les étapes 4 à 6 jusqu'à ce que le nombre d'itérations spécifié soit atteint ou que la condition d'arrêt soit remplie.

% 设置变量范围和样本数量
rangeX = [0 1]; % X 变量范围
rangeY = [0 1]; % Y 变量范围
numSamples = 20; % 样本数量

% 最大最小距离法生成拉丁超立方设计
design = maxminLHD(numSamples, 2);

% 将设计映射到指定的变量范围
samplesX = design(:, 1) * (rangeX(2) - rangeX(1)) + rangeX(1);
samplesY = design(:, 2) * (rangeY(2) - rangeY(1)) + rangeY(1);

% 绘制二维图
scatter(samplesX, samplesY, 'filled');
xlabel('X');
ylabel('Y');
title('Optimized Latin Hypercube Design using Max-Min Distance');

% 最大最小距离法生成优化的拉丁超立方设计函数
function design = maxminLHD(numSamples, numVariables)
    design = lhsdesign(numSamples, numVariables);
    
    % 进行最大最小距离优化
    for i = 1:numVariables
        col = design(:, i);
        col = (col - min(col)) / (max(col) - min(col));
        design(:, i) = col;
    end
end

3.4 Optimisation de l'entropie maximale

La méthode d'entropie maximale trouve la disposition optimale des points d'échantillonnage grâce à une optimisation itérative afin de maximiser l'incertitude de la distribution des points d'échantillonnage. En ajustant en permanence la position des points d'échantillonnage et en conservant les contraintes, la méthode d'entropie maximale peut améliorer la conception de l'hypercube latin, de sorte que les points d'échantillonnage soient répartis plus uniformément et couvrent tout l'espace d'échantillonnage.

1 Déterminez la plage et les contraintes des variables, telles que les valeurs minimales et maximales pour chaque variable.

2 Générez la conception initiale de l'hypercube latin.

3 Calculez l'entropie de la conception initiale en tant qu'entropie maximale actuelle.

4 itérations d'optimisation sont effectuées, et chaque itération génère un nouveau design et calcule son entropie.

5 À chaque itération, pour chaque point d'échantillonnage, un nouvel emplacement est généré par réaffectation aléatoire. Cela peut être fait en échangeant les positions des deux points d'échantillonnage ou en choisissant au hasard une nouvelle position dans la plage des points d'échantillonnage.

6 Ajustez les emplacements des points d'échantillonnage dans le nouveau plan en fonction des contraintes pour vous assurer qu'il est conforme à la plage et aux contraintes des variables.

7 Calculez l'entropie du nouveau design.

8 Si l'entropie de la nouvelle conception est supérieure à l'entropie maximale actuelle, acceptez la nouvelle conception comme la conception optimale actuelle ; sinon, conservez la conception précédente.

9 Répétez les étapes 4 à 8 jusqu'à ce que le nombre d'itérations spécifié soit atteint ou que la condition d'arrêt soit remplie.

% 设置变量范围和样本数量
rangeX = [0 1]; % X 变量范围
rangeY = [0 1]; % Y 变量范围
numSamples = 20; % 样本数量

% 最大熵法生成拉丁超立方设计
design = maxEntropyLHD(numSamples, 2);

% 将设计映射到指定的变量范围
samplesX = design(:, 1) * (rangeX(2) - rangeX(1)) + rangeX(1);
samplesY = design(:, 2) * (rangeY(2) - rangeY(1)) + rangeY(1);

% 绘制二维图
scatter(samplesX, samplesY, 'filled');
xlabel('X');
ylabel('Y');
title('Optimized Latin Hypercube Design using Maximum Entropy');

% 最大熵法生成优化的拉丁超立方设计函数
function design = maxEntropyLHD(numSamples, numVariables)
    design = lhsdesign(numSamples, numVariables);
    
    % 进行最大熵法优化
    for i = 1:numVariables
        col = design(:, i);
        col = -log(1 - col);
        col = (col - min(col)) / (max(col) - min(col));
        design(:, i) = col;
    end
end

3.5 Optimisation de l'algorithme de recuit simulé

Grâce au processus d'optimisation itératif de l'algorithme de recuit simulé, la qualité de la conception de l'hypercube latin peut être progressivement améliorée. Au fur et à mesure que la température diminue, l'algorithme a tendance à accepter des solutions avec des différences plus petites, convergeant ainsi progressivement vers une meilleure conception.
1 Initialiser la solution initiale : générer une conception initiale d'hypercube latin comme solution actuelle.

2. Réglez la température initiale et la stratégie de recuit : déterminez la température initiale et la stratégie de recuit, par exemple, la température initiale est plus élevée et la température diminue progressivement pendant le processus de recuit.

3. Processus d'optimisation itératif : à chaque itération, une solution adjacente est sélectionnée en fonction de la température actuelle. Des solutions adjacentes peuvent être obtenues en perturbant de manière aléatoire les positions des points d'échantillonnage de la solution actuelle ou en effectuant des opérations d'optimisation, telles que l'échange des positions de deux points d'échantillonnage.

4 Calculez la différence ou la fonction de coût entre la solution actuelle et les solutions adjacentes : Calculez la différence ou la valeur de la fonction de coût entre la solution actuelle et les solutions adjacentes. La différence peut être une mesure de la distance entre les points d'échantillonnage, une corrélation linéaire, etc.

5 Calculez la probabilité d'accepter la différence en fonction de la différence et de la température actuelle : Calculez la probabilité d'accepter une solution adjacente en fonction de la différence et de la température actuelle. En général, la probabilité d'accepter une solution adjacente est plus élevée si la différence est plus petite ou si la température actuelle est plus élevée.

6 Accepter ou rejeter des solutions adjacentes basées sur des probabilités : accepter ou rejeter des solutions adjacentes basées sur des probabilités. Si la solution adjacente est acceptée, faites-en la solution courante ; sinon, gardez la solution courante inchangée.

7 Abaisser la température : abaisser la température selon la stratégie de recuit, comme réduire la proportion de la température ou ajuster la température en fonction du nombre d'itérations.

Répétez les étapes 3 à 7 jusqu'à ce qu'une condition d'arrêt soit remplie (par exemple, le nombre maximum d'itérations est atteint ou la température est inférieure à un certain seuil).

% 设置变量范围和样本数量
rangeX = [0 1]; % X 变量范围
rangeY = [0 1]; % Y 变量范围
numSamples = 20; % 样本数量

% 模拟退火算法生成优化的拉丁超立方设计
design = simulatedAnnealingLHD(numSamples, 2, rangeX, rangeY);

% 绘制二维图
scatter(design(:,1), design(:,2), 'filled');
xlabel('X');
ylabel('Y');
title('Optimized Latin Hypercube Design using Simulated Annealing');

% 模拟退火算法生成优化的拉丁超立方设计函数
function design = simulatedAnnealingLHD(numSamples, numVariables, rangeX, rangeY)
    % 初始化设计
    design = lhsdesign(numSamples, numVariables);
    
    % 定义能量函数
    function energy = energyFunction(design)
        % 将设计映射到变量范围
        samplesX = design(:, 1) * (rangeX(2) - rangeX(1)) + rangeX(1);
        samplesY = design(:, 2) * (rangeY(2) - rangeY(1)) + rangeY(1);
        
        % 计算设计的能量（距离的总和）
        distances = pdist([samplesX, samplesY]);
        energy = sum(distances);
    end

    % 进行模拟退火优化
    initialEnergy = energyFunction(design);
    currentDesign = design;
    currentEnergy = initialEnergy;
    
    temperature = 1;
    coolingRate = 0.95;
    
    while temperature > 1e-8
        % 随机选择两个变量进行交换
        i = randi([1, numSamples]);
        j = randi([1, numSamples]);
        
        newDesign = currentDesign;
        newDesign([i j], :) = newDesign([j i], :);
        newEnergy = energyFunction(newDesign);
        
        % 根据 Metropolis 准则接受或拒绝新设计
        if newEnergy < currentEnergy
            currentDesign = newDesign;
            currentEnergy = newEnergy;
        else
            acceptanceProbability = exp((currentEnergy - newEnergy) / temperature);
            if rand < acceptanceProbability
                currentDesign = newDesign;
                currentEnergy = newEnergy;
            end
        end
        
        % 降低温度
        temperature = temperature * coolingRate;
    end
    
    % 返回优化后的设计
    design = currentDesign;
end

3.6 Optimisation moyenne pour réduire la dépendance linéaire

RLCMO) est une méthode d'optimisation pour améliorer l'uniformité et la corrélation des conceptions d'hypercubes latins. Son objectif est d'obtenir une meilleure distribution uniforme en ajustant la position des points d'échantillonnage dans la conception de l'hypercube latin afin que la corrélation linéaire entre les points d'échantillonnage dans la conception soit aussi faible que possible.
Les étapes spécifiques du RLCMO sont les suivantes :

1 Tout d'abord, générez une conception initiale d'hypercube latin.

2 Calculez le nombre conditionnel de la matrice de conception, qui mesure la dépendance linéaire de la conception actuelle.

3 Effectuez des itérations d'optimisation, chaque itération générant une nouvelle conception et calculant son numéro de condition.

5. Ajustez l'emplacement du point d'échantillonnage dans le nouveau plan en fonction des contraintes pour vous assurer qu'il est conforme à la plage et aux contraintes des variables.

6 Calculez le numéro de condition de la nouvelle conception.

7 Si le numéro de condition de la nouvelle conception est inférieur au numéro de condition actuel, accepter la nouvelle conception comme la conception optimale actuelle ; sinon, accepter la nouvelle conception selon une certaine probabilité.

8 Répétez les étapes 3 à 7 jusqu'à ce que le nombre d'itérations spécifié soit atteint ou que la condition d'arrêt soit remplie.

% 设置变量范围和样本数量
rangeX = [0 1]; % X 变量范围
rangeY = [0 1]; % Y 变量范围
numSamples = 20; % 样本数量

% 减小线性相关性的均值优化生成拉丁超立方设计
design = reduceCorrelationLHD(numSamples, 2);

% 将设计映射到指定的变量范围
samplesX = design(:, 1) * (rangeX(2) - rangeX(1)) + rangeX(1);
samplesY = design(:, 2) * (rangeY(2) - rangeY(1)) + rangeY(1);

% 绘制二维图
scatter(samplesX, samplesY, 'filled');
xlabel('X');
ylabel('Y');
title('Optimized Latin Hypercube Design with Reduced Correlation');

% 减小线性相关性的均值优化生成拉丁超立方设计函数
function design = reduceCorrelationLHD(numSamples, numVariables)
    design = lhsdesign(numSamples, numVariables);
    
    % 减小线性相关性的均值优化
    for i = 1:numVariables
        col = design(:, i);
        col = col - mean(col);
        design(:, i) = col;
    end
end

3.7 Méthode d'optimisation de la stratégie gloutonne

La stratégie gloutonne est une méthode d'optimisation basée sur le choix de l'optimum local, qui peut être utilisée pour optimiser les conceptions d'hypercubes latins. La méthode sélectionne et ajuste l'emplacement des points d'échantillonnage étape par étape pour maximiser l'uniformité et la corrélation de la conception.

L'idée de base de la stratégie gourmande est de partir de la conception initiale et de faire des ajustements d'optimisation un par un pour améliorer les caractéristiques de la conception. Les étapes spécifiques sont les suivantes :
En résumé, la minimisation de la distance est une méthode courante pour optimiser les conceptions d'hypercubes latins et peut produire des résultats de distribution uniforme satisfaisants dans la plupart des cas.
1 Générez une conception initiale d'hypercube latin.

2 Pour chaque point d'échantillonnage, sélectionnez une position optimale pour le réglage selon certaines règles. Ici, un indice d'évaluation doit être défini pour mesurer les avantages et les inconvénients de chaque emplacement, par exemple, un indice de distance ou un indice de corrélation peut être utilisé.

3 Pour la position optimale sélectionnée, déplacez le point d'échantillonnage actuel vers cette position et mettez à jour la matrice de conception.

4 Répétez les étapes 2 et 3 jusqu'à ce que tous les points d'échantillonnage soient réglés de manière optimale.

5 Évaluez la conception optimisée finale pour vérifier l'amélioration de l'homogénéité et de la corrélation. Si une optimisation supplémentaire est nécessaire, vous pouvez recommencer à partir de l'étape 2 ou utiliser d'autres méthodes d'optimisation pour une amélioration itérative.

% 贪心策略生成优化的拉丁超立方设计函数
function design=lhs(rangeX,rangeY,rangeZ,rangeW,numSamples,iterCount)
% 贪心策略生成优化的拉丁超立方设计
design = greedyOptimizationLHD(numSamples, 4, rangeX, rangeY, rangeZ, rangeW, iterCount);

% 打印优化后的设计样本点
disp(design);
end


% 贪心策略生成优化的拉丁超立方设计函数
function design = greedyOptimizationLHD(numSamples, numVariables, rangeX, rangeY, rangeZ, rangeW, iterCount)
    % 生成初始的拉丁超立方设计
    design = lhsdesign(numSamples, numVariables);
    
    % 将设计映射到变量范围
    samplesX = design(:, 1) * (rangeX(2) - rangeX(1)) + rangeX(1);
    samplesY = design(:, 2) * (rangeY(2) - rangeY(1)) + rangeY(1);
    samplesZ = design(:, 3) * (rangeZ(2) - rangeZ(1)) + rangeZ(1);
    samplesW = design(:, 4) * (rangeW(2) - rangeW(1)) + rangeW(1);
    
    % 计算初始设计的适应度
    initialFitness = calculateFitness(samplesX, samplesY, samplesZ, samplesW);
    
    % 迭代改进设计
    for iter = 1:iterCount
        % 随机选择一个样本点
        index = randi(numSamples);

        % 保存上一轮迭代的样本点
        prevX = samplesX(index);
        prevY = samplesY(index);
        prevZ = samplesZ(index);
        prevW = samplesW(index);
        
        % 随机生成新的样本点
        newX = rand * (rangeX(2) - rangeX(1)) + rangeX(1);
        newY = rand * (rangeY(2) - rangeY(1)) + rangeY(1);
        newZ = rand * (rangeZ(2) - rangeZ(1)) + rangeZ(1);
        newW = rand * (rangeW(2) - rangeW(1)) + rangeW(1);
        
        % 替换选中的样本点
        samplesX(index) = newX;
        samplesY(index) = newY;
        samplesZ(index) = newZ;
        samplesW(index) = newW;
        
        % 计算新设计的适应度
        newFitness = calculateFitness(samplesX, samplesY, samplesZ, samplesW);
        
        % 如果新设计的适应度更好，则接受新设计
        if newFitness > initialFitness
            initialFitness = newFitness;
        else
            % 恢复原来的样本点
            samplesX(index) = design(index, 1) * (rangeX(2) - rangeX(1)) + rangeX(1);
            samplesY(index) = design(index, 2) * (rangeY(2) - rangeY(1)) + rangeY(1);
            samplesZ(index) = design(index, 3) * (rangeZ(2) - rangeZ(1)) + rangeZ(1);
            samplesW(index) = design(index, 4) * (rangeW(2) - rangeW(1)) + rangeW(1);

            samplesX(index) = prevX;
            samplesY(index) = prevY;
            samplesZ(index) = prevZ;
            samplesW(index) = prevW;
        end
    end
    
    % 更新最终的设计,是有每轮更新的,这种是做了归一化处理的
    design(:, 1) = (samplesX - rangeX(1)) / (rangeX(2) - rangeX(1));
    design(:, 2) = (samplesY - rangeY(1)) / (rangeY(2) - rangeY(1));
    design(:, 3) = (samplesZ - rangeZ(1)) / (rangeZ(2) - rangeZ(1));
    design(:, 4) = (samplesW - rangeW(1)) / (rangeW(2) - rangeW(1));

    design(:, 1) = samplesX;
    design(:, 2) = samplesY;
    design(:, 3) = samplesZ;
    design(:, 4) = samplesW;
end

% 计算设计的适应度
function fitness = calculateFitness(samplesX, samplesY, samplesZ, samplesW)
    % 计算设计的适应度（距离的总和的倒数）
    distances = pdist([samplesX, samplesY, samplesZ, samplesW]);
    fitness = 1 / sum(distances);
end

Ce code implémente une conception optimisée d'hypercube latin utilisant une génération de stratégie gourmande. Voici l'explication et la fonction du code :

rangeX et rangeY sont les plages des variables X et Y.
numSamples est le nombre d'échantillons à générer.
design = greedyOptimizationLHD(numSamples, 2, rangeX, rangeY); Appelez la fonction greedyOptimizationLHD pour générer une conception optimisée d'hypercube latin.
scatter(design(:,1), design(:,2), 'filled'); Dessine un tracé 2D montrant les points de conception résultants.
La fonction greedyOptimizationLHD implémente le processus de génération d'un design d'hypercube latin optimisé par une stratégie gloutonne.
Tout d'abord, il génère une conception initiale d'hypercube latin à l'aide de la fonction lhsdesign.
Ensuite, mappez la conception aux plages de variables spécifiées.
Ensuite, calculez la fitness de la conception initiale, où la fitness est définie comme l'inverse de la somme des distances.
Améliorez la conception de manière itérative, chaque itération sélectionne au hasard un point d'échantillonnage, génère au hasard un nouveau point d'échantillonnage et remplace le point d'échantillonnage sélectionné. Si l'adéquation du nouveau plan est meilleure, acceptez le nouveau plan ; sinon, restaurez les points d'échantillonnage d'origine.
Enfin, mettez à jour la conception finale et revenez.
La fonction calculateFitness calcule l'adéquation d'un plan. Ici, la forme physique est définie comme l'inverse de la somme des distances, et la minimisation de la distance est une méthode courante pour optimiser les conceptions d'hypercubes latins.
Veuillez noter que le nombre d'itérations dans le code est fixé à 100, ce qui est un paramètre ajustable et peut être ajusté en fonction de la situation spécifique. De plus, la méthode de calcul de fitness conçue peut également être modifiée selon les besoins.

Oui, dans ce code, le calcul de la fitness est basé sur la somme des distances entre les points d'échantillonnage. Par conséquent, plus la somme des distances est petite, plus la fitness est élevée, ce qui signifie que la distribution des points d'échantillonnage est plus uniforme.

En minimisant la somme des distances entre les points d'échantillonnage, les points d'échantillonnage peuvent être répartis uniformément sur toute la plage variable. C'est l'une des méthodes courantes pour optimiser les conceptions d'hypercubes latins et produit des résultats satisfaisants dans la plupart des cas.

Lorsque la distance entre les points d'échantillonnage est petite, ils sont plus proches d'une distribution uniforme. Cela garantit une couverture globale de l'espace de conception et réduit la redondance entre les points d'échantillonnage. De telles conceptions permettent une meilleure représentation des caractéristiques latentes sur la gamme de variables et pour l'exploration de l'espace de solution de problèmes expérimentaux ou d'optimisation.

Si votre domaine problématique a différentes plages dans différentes dimensions et que ces plages varient considérablement, je vous recommande d'utiliser les résultats de conception normalisés. La normalisation peut unifier la plage des différentes dimensions à la plage de [0, 1], de sorte que les changements entre les différentes dimensions ont une échelle relativement cohérente.

L'utilisation de résultats de conception normalisés présente les avantages suivants :

Échelle unifiée : la normalisation peut éliminer les différences d'échelle entre les différentes dimensions, en veillant à ce qu'elles aient des plages relativement cohérentes. De cette façon, vous pouvez plus facilement comparer et peser les effets de différentes dimensions.
Réutilisabilité : les résultats de conception normalisés peuvent être plus facilement intégrés à d'autres modèles, algorithmes ou méthodes. Vous pouvez importer la conception dans d'autres modèles en utilisant la même plage normalisée sans mise à l'échelle supplémentaire.
Interprétabilité : les résultats de conception normalisés sont plus faciles à comprendre et à interpréter car ils se situent dans une plage uniforme. Vous pouvez utiliser directement les valeurs normalisées, quelle que soit l'étendue réelle de chaque dimension.
Donc, si votre problème implique plusieurs dimensions avec différentes plages, je vous recommande d'utiliser le résultat de conception normalisé. Cela peut mieux gérer la différence d'échelle entre les différentes dimensions et rendre l'analyse et l'application ultérieures plus pratiques.