polyfit

R2026b

Ajuster des courbes polynomiales

Syntaxe

coeffs = polyfit(x,y,n)

[coeffs,fitStats] = polyfit(x,y,n)

[coeffs,fitStats,centerScale] = polyfit(x,y,n,Normalize=tf)

Description

coeffs = polyfit(x,y,n) renvoie les coefficients d’un polynôme p(x) de degré n qui est le meilleur ajustement pour les données de y au sens des moindres carrés. Le polynôme résultant est :

$$p(x)=\mathrm{coeffs}(1)\cdot x^n+\mathrm{coeffs}(2)\cdot x^{n-1}+\mathrm{...}+\mathrm{coeffs}(n)\cdot x+\mathrm{coeffs}(n+1).$$

[coeffs,fitStats] = polyfit(x,y,n) renvoie également des statistiques d’ajustement qui peuvent être utilisées pour estimer l’erreur de prédiction avec la fonction polyval.

[coeffs,fitStats,centerScale] = polyfit(x,y,n,Normalize=tf) offre la possibilité d’appliquer une normalisation lors de l’ajustement. Si vous définissez Normalize sur true, polyfit centre x sur 0 et le met à l’échelle pour obtenir un écart-type égal à 1 conformément à la transformation $$\widehat{x}=\frac{x-\overline{x}}{{\sigma }_x}.$$ Dans ce cas, polyfit renvoie également la sortie centerScale sous forme de vecteur à deux éléments contenant les valeurs de centre et de mise à l’échelle, à savoir mean(x) et std(x). Si vous définissez Normalize sur false, polyfit ne transforme pas x, et centerScale est un vecteur à deux éléments contenant les valeurs 0 et 1. (depuis R2026b)

Avant la version R2026b : la normalisation est contrôlée de manière implicite par le nombre d’arguments en sortie. Le renvoi d’un troisième argument en sortie active automatiquement la normalisation. Consultez Historique des versions pour plus d’informations.

Exemples

Régression linéaire simple

Ajustez un modèle de régression linéaire simple sur un ensemble de points de données discrets en 2D.

Créez deux exemples de vecteurs de points de données (x, y). Ajustez un polynôme du premier degré sur les données.

x = 1:50; 
y = -0.3*x + 2*randn(1,50); 
coeffs = polyfit(x,y,1); 

Évaluez le polynôme ajusté aux points de x. Tracez le modèle de régression linéaire obtenu avec les données.

f = polyval(coeffs,x);

plot(x,y,"o")
hold on
plot(x,f)
legend("Sample data","First-degree polynomial")
hold off

Ajuster un polynôme sur une fonction trigonométrique

Générez 10 points régulièrement espacés le long d’une courbe sinusoïdale dans l’intervalle [0,4*pi].

x = linspace(0,4*pi,10);
y = sin(x);

Ajustez un polynôme du septième degré sur les données.

coeffs = polyfit(x,y,7);

Évaluez le polynôme ajusté sur une grille plus fine et tracez les résultats.

x2 = linspace(0,4*pi);
yfit = polyval(coeffs,x2);

plot(x,y,"o")
hold on
plot(x2,yfit)
legend("Sample data","Seventh-degree polynomial")
hold off

Ajuster un polynôme sur un jeu de points

Créez un vecteur de 5 points régulièrement espacés dans l’intervalle [0,1] et évaluez $y\left(x\right)=\frac{1}{1+x}$ au niveau de ces points.

x = linspace(0,1,5);
y = 1./(1+x);

Ajustez un polynôme du quatrième degré sur les données. Généralement pour n points, vous pouvez ajuster un polynôme de degré n-1 afin qu’il passe exactement par les points.

coeffs = polyfit(x,y,4);

Évaluez la fonction originale et l’ajustement polynomial sur une grille de points plus fine entre 0 et 2.

x2 = linspace(0,2);
yfcn = 1./(1+x2);
yfit = polyval(coeffs,x2);

Tracez les valeurs de la fonction et l’ajustement polynomial dans l’intervalle plus large de [0,2], les points utilisés pour obtenir l’ajustement polynomial étant mis en évidence par des cercles. L’ajustement polynomial est bon dans l’intervalle original de [0,1], mais diverge rapidement de la fonction d’origine en dehors de cet intervalle.

plot(x,y,"o")
hold on
plot(x2,yfcn)
plot(x2,yfit,"--")
legend("Sample data","1/(1+x)","Fourth-degree polynomial")
hold off

Ajuster un polynôme sur une fonction d’erreur

Générez dans un premier temps un vecteur de points régulièrement espacés dans l’intervalle [0,2.5], puis évaluez erf(x) au niveau de ces points.

x = (0:0.1:2.5)';
y = erf(x);

Ajustez un polynôme du sixième degré sur les données.

coeffs = polyfit(x,y,6)

coeffs = 1×7

    0.0084   -0.0983    0.4217   -0.7435    0.1471    1.1064    0.0004

Pour déterminer la qualité de l’ajustement, évaluez le polynôme aux points de données et générez une table indiquant les données, l'ajustement et l’erreur.

yfit = polyval(coeffs,x);
T = table(x,y,yfit,y-yfit,VariableNames=["X" "Y" "Fit" "FitError"])

T = 26×4 table
     X        Y          Fit         FitError  
    ___    _______    __________    ___________

      0          0    0.00044117    -0.00044117
    0.1    0.11246       0.11185     0.00060836
    0.2     0.2227       0.22231     0.00039189
    0.3    0.32863       0.32872    -9.7429e-05
    0.4    0.42839        0.4288    -0.00040661
    0.5     0.5205       0.52093    -0.00042568
    0.6    0.60386       0.60408    -0.00022824
    0.7     0.6778       0.67775     4.6383e-05
    0.8     0.7421       0.74183     0.00026992
    0.9    0.79691       0.79654     0.00036515
      1     0.8427       0.84238      0.0003164
    1.1    0.88021       0.88005     0.00015948
    1.2    0.91031       0.91035    -3.9919e-05
    1.3    0.93401       0.93422      -0.000211
    1.4    0.95229       0.95258    -0.00029933
    1.5    0.96611       0.96639    -0.00028097
      ⋮

Dans cet intervalle, les valeurs interpolées et les valeurs réelles sont assez proches. Créez un tracé pour montrer qu’en dehors de cet intervalle, les valeurs extrapolées divergent rapidement des données réelles.

x2 = (0:0.1:5)';
fcnextrap = erf(x2);
fitextrap = polyval(coeffs,x2);

plot(x,y,"o")
hold on
plot(x2,fcnextrap)
plot(x2,fitextrap,"--")
xlim([0 5])
legend("Sample data","erf(x)","Sixth-degree polynomial")
hold off

Normaliser les données pour améliorer le conditionnement numérique

Créez un échantillon de données démographiques pour les années 1750 à 2000 et tracez les points de données.

x = 1750:25:2000;
y = 1e6*[791 856 978 1050 1262 1544 1650 2532 6122 8170 11560];

Utilisez polyfit pour ajuster un polynôme du cinquième degré sur les données. Vous pouvez améliorer le conditionnement numérique en normalisant le vecteur de requête avant d’ajuster un polynôme. Cet exemple consiste à normaliser les données year et à calculer un ajustement polynomial du cinquième degré. La fonction renvoie également le centre et l’échelle utilisés pour la normalisation.

[coeffsNorm,~,centerScale] = polyfit(x,y,5,Normalize=true);

Normalisez les points de requête avec le même centre et la même échelle, puis évaluez le polynôme en spécifiant centerScale lorsque vous appelez la fonction polyval. Tracez ensuite les résultats.

yfit = polyval(coeffsNorm,x,[],centerScale);

plot(x,y,"o")
hold on
plot(x,yfit)
legend("Sample data","Fifth-degree polynomial")
hold off

Régression linéaire avec estimation d’erreurs

Ajustez un modèle linéaire sur un jeu de points de données et tracez les résultats, en incluant une estimation de l’intervalle de prédiction à 95 %.

Créez quelques exemples de vecteurs de points de données (x, y). Utilisez polyfit pour ajuster un polynôme du premier degré sur les données. Spécifiez deux sorties pour renvoyer les coefficients de l'ajustement linéaire ainsi que la structure d’estimation d’erreurs.

x = 0:100; 
y = -0.3*x + 2*randn(1,101); 
[coeffs,fitStats] = polyfit(x,y,1);

Évaluez le polynôme du premier degré aux points de x. Spécifiez la structure d’estimation d’erreurs en tant que troisième entrée pour que polyval calcule une estimation d’erreur standard. L’estimation de l’erreur standard est renvoyée dans delta.

[yfit,delta] = polyval(coeffs,x,fitStats);

Tracez les données d'origine, l'ajustement linéaire et l’intervalle de prédiction à 95 % $yfit\pm 2\Delta$.

plot(x,y,"o")
hold on
plot(x,yfit)

xinterval = [x flip(x)];
yinterval = [yfit-2*delta flip(yfit)+2*delta];
interval = fill(xinterval,yinterval,"yellow",FaceAlpha=0.2);

legend("Sample data","First-degree polynomial","95% prediction interval")
hold off

Arguments d'entrée

x — Points de requête

vecteur

Points de requête, spécifiés sous forme de vecteur. Les points de requête de x correspondent aux valeurs ajustées dans y. Si x n’est pas un vecteur, polyfit le convertit en un vecteur colonne x(:).

Un ajustement mal conditionné peut être dû à des points de requête répétés (ou presque répétés) ou largement espacés ou bien à l’utilisation d’un degré polynomial élevé. Pour améliorer le conditionnement, ajoutez des points de requête distincts, normalisez les données en spécifiant Normalize=true ou réduisez le degré.

Types de données : double | single
Support des nombres complexes : Oui

y — Valeurs ajustées aux points de requête

vecteur

Valeurs ajustées aux points de requête, spécifiées sous forme de vecteur. Les valeurs ajustées de y correspondent aux points de requête dans x. Si y n’est pas un vecteur, polyfit le convertit en un vecteur colonne y(:).

Types de données : double | single
Support des nombres complexes : Oui

n — Degré d'ajustement polynomial

scalaire entier positif

Degré d’ajustement polynomial, spécifié sous forme de scalaire entier positif. n spécifie la puissance polynomiale du premier coefficient de coeffs.

Un ajustement mal conditionné peut être dû à un degré polynomial élevé. Pour améliorer le conditionnement, réduisez le degré.

tf — Option de normalisation des points de requête

true ou 1 | false ou 0

Depuis R2026b

Option de normalisation des points de requête de x avant l’ajustement, spécifiée sous forme d’une des valeurs suivantes pour le paramètre Normalize :

• true ou 1 : normaliser les points de requête de x avant l’ajustement du polynôme en les centrant sur 0 et en les mettant à l’échelle avec un écart-type de 1.

• false ou 0 : ne pas normaliser les points de requête de x avant l’ajustement du polynôme.

Si vous spécifiez la troisième sortie centerScale, alors polyfit utilise Normalize=true par défaut. Sinon, la valeur par défaut est Normalize=false.

La normalisation améliore le conditionnement numérique, en particulier pour les polynômes de degré supérieur ou les points de requête largement espacés.

Exemple : [coeffs,~,centerScale] = polyfit(x,y,n,Normalize=true) normalise les points de requête de x, ajuste un polynôme de degré n et renvoie le centre et la valeur de mise à l’échelle en plus des coefficients polynomiaux calculés en fonction des points de requête normalisés.

Arguments de sortie

coeffs — Coefficients de l’ajustement polynomial par la méthode des moindres carrés

vecteur

Coefficients de l’ajustement polynomial par la méthode des moindres carrés, renvoyés sous forme d’un vecteur. coeffs est de longueur n+1 et contient les coefficients polynomiaux en puissances décroissantes, le degré polynomial étant n.

Si x ou y contient une ou plusieurs valeurs NaN et que n < length(x), alors tous les éléments de coeffs sont NaN.

Vous pouvez évaluer le polynôme représenté par coeffs avec polyval. Si vous appelez polyfit avec Normalize=true, alors coeffs ne contient pas les mêmes coefficients polynomiaux que pour les données non normalisées. Avec des données normalisées, vous devez également spécifier centerScale lorsque vous évaluez le polynôme avec polyval.

fitStats — Statistiques d’ajustement

structure

Statistiques d’ajustement, renvoyées sous forme de structure contenant les champs suivants.

Champ	Description
R	Facteur R triangulaire (éventuellement permuté) d’une décomposition QR de la matrice de Vandermonde de x
df	Degrés de liberté de l’ajustement
normr	Norme euclidienne des résidus
rsquared (depuis R2024a)	Coefficient de détermination (R au carré non ajusté)

Vous pouvez estimer l’erreur standard de prédiction d’une observation future en utilisant fitStats avec polyval. Si vous appelez polyfit avec Normalize=true, spécifiez centerScale en plus de fitStats lors de l’utilisation de polyval.

Pour estimer la covariance des coefficients polynomiaux si les données de y sont aléatoires, utilisez (Rinv*Rinv')*normr^2/df, où Rinv est l’inverse de R.

centerScale — Valeurs de centre et de mise à l’échelle

vecteur à deux éléments

Valeurs de centre et de mise à l’échelle utilisées pour normaliser les points de requête de x, renvoyées sous la forme d’un vecteur à deux éléments.

• Si vous spécifiez Normalize=true, alors centerScale(1) est égal à mean(x) et centerScale(2) est égal à std(x).

• Si vous spécifiez Normalize=false, alors centerScale(1) est égal à 0 et centerScale(2) est égal à 1.

Si vous souhaitez évaluer le polynôme ajusté avec la même normalisation, vous pouvez spécifier centerScale en tant que quatrième entrée de polyval.

Limitations

• Pour les problèmes comportant de nombreux points, l’augmentation du degré de l’ajustement polynomial via polyfit ne permet pas toujours d’obtenir une meilleure correspondance. Les polynômes d’ordre élevé peuvent osciller entre les points de données, ce qui produit un mauvais ajustement aux données. Dans de tels cas, vous pouvez utiliser un ajustement polynomiale d’ordre inférieur (qui tend à être plus lisse entre les points) ou une technique différente, en fonction du problème.

• Par nature, les polynômes sont des fonctions oscillantes non bornées. Elles ne sont donc pas adaptées à l’extrapolation de données bornées ou de données monotones (toujours croissantes ou toujours décroissantes).

Algorithmes

polyfit utilise x pour former une matrice de Vandermonde V avec n+1 colonnes et m = length(x) lignes, ce qui donne le système linéaire

$$\left(\begin{array}{cccc}{x}_1^n& x_1^{n-1}& \cdots & 1\\ x_2^n& x_2^{n-1}& \cdots & 1\\ ⋮& ⋮& \ddots & ⋮\\ x_m^n& x_m^{n-1}& \cdots & 1\end{array}\right)\left(\begin{array}{c}{p}_1\\ p_2\\ ⋮\\ p_{n+1}\end{array}\right)=\left(\begin{array}{c}{y}_1\\ y_2\\ ⋮\\ y_m\end{array}\right),$$

que polyfit résout avec coeffs = V\y. Puisque les colonnes de la matrice de Vandermonde sont des puissances du vecteur x, le nombre de conditions de V est souvent élevé pour les correspondances d’ordre élevé, ce qui se traduit par une matrice de coefficients singulière. Dans de tels cas, le fait de spécifier Normalize=true peut améliorer les propriétés numériques du système et produire un ajustement plus fiable.

Capacités étendues

Tall arrays

Calculer avec des arrays possédant plus de rangées que la mémoire ne peut en contenir.

La fonction polyfit supporte les tall arrays avec les notes d’usage et limitations suivantes :

x et y doivent être des vecteurs colonne.

Pour plus d’informations, consultez Tall array.

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d’usage et limitations :

• Pour les arguments en entrée x et y :

  • Vous devez spécifier le vecteur en entrée comme étant de taille fixe ou de longueur variable au moment de la génération de code. Seule la première ou la deuxième dimension du vecteur peut être de taille variable. Toutes les autres dimensions doivent être de taille fixe égale à 1.

Génération de code GPU

Générez du code CUDA® pour les GPU NVIDIA® avec GPU Coder™.

Consultez les notes d’usage et limitations à la section « Génération de code C/C++ ». Les mêmes notes d’usage et limitations s’appliquent à la génération de code GPU.

Environnement basé sur les threads

Exécutez du code en arrière-plan avec MATLAB® backgroundPool ou accélérez le code avec Parallel Computing Toolbox™ ThreadPool.

La fonction polyfit supporte entièrement les environnements basés sur des threads. Pour plus d’informations, consultez Run MATLAB Functions in Thread-Based Environment.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

La fonction polyfit supporte entièrement les GPU arrays. Pour exécuter la fonction sur un GPU, spécifiez les données en entrée en tant que gpuArray (Parallel Computing Toolbox). Pour plus d’informations, consultez Exécuter les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Distributed arrays

Divisez les tableaux volumineux dans la mémoire combinée de votre cluster avec Parallel Computing Toolbox™.

La fonction polyfit supporte entièrement les distributed arrays. Pour plus d’informations, consultez Exécuter les fonctions MATLAB avec des tableaux distribués (Parallel Computing Toolbox).

Historique des versions

Introduit avant R2006a

R2026b: Contrôler de manière explicite la normalisation des points de requête

Spécifiez l’argument Normalize pour contrôler de manière explicite si polyfit normalise ou non les points de requête avant l’ajustement.

Si vous spécifiez Normalize=true, alors polyfit centre les points de requête sur 0 et les met à l’échelle avec un écart-type de 1 avant l’ajustement. Les coefficients polynomiaux et les statistiques d’ajustement renvoyés sont calculés en fonction des points de requête normalisés $$\widehat{x}=\frac{x-\overline{x}}{{\sigma }_x}.$$

Auparavant, la normalisation était contrôlée de manière implicite par le nombre d’arguments en sortie. Par exemple, le fait de spécifier un troisième argument tel que [coeffs,~,centerScale] = polyfit(x,y,n) normalisait automatiquement les points de requête. Cette syntaxe est toujours supportée. Il est toutefois recommandé d’utiliser Normalize, car le comportement de la normalisation est ainsi explicite et indépendant du nombre d’arguments en sortie.

R2024a: Inclusion de la valeur R au carré dans la structure d’estimation des erreurs

Lorsque vous renvoyez la structure de statistiques d’ajustement fitStats comme deuxième sortie, elle inclut le champ rsquared. rsquared est le coefficient de détermination ou valeur R au carré (non ajustée). Utilisez fitStats avec la fonction polyval pour obtenir des estimations d’erreur.

Voir aussi

Fonctions

• polyval | cov | lscov | poly | polyint | polyder | roots

Rubriques

• Programmatic Fitting
• Régression linéaire avec une seule variable prédictive