Appliquer la formule de propagation d'erreur à l'erreur standard

Il y a quelque chose qui s'appelle une formule de propagation d'erreur. L'explication de la formule de propagation d'erreur est décrite ci-dessous. Puisque COV (a, b) est covariant, il sera nul si les erreurs de a et b sont indépendantes.

y(a,b)Alors y erreur σ_{y}Est,Erreur d'un σ_{a}Et b erreur σ_{b}Sera comme suit en utilisant.

σ_{y}^2 = (\frac{∂y}{∂a})^2 σ_{a}^2 +  (\frac{∂y}{∂b})^2 σ_{b}^2+ 2COV(a,b)\frac{∂y}{∂a}\frac{∂y}{∂b}

Cette fois, j'ai examiné si la formule de propagation d'erreur pouvait être appliquée à l'erreur standard.

Qu'est-ce qu'une erreur standard?

Vous trouverez ci-dessous une explication des statistiques sur ce qu'est l'erreur standard en premier lieu.

Supposons que vous souhaitiez estimer les paramètres de la répartition de la population à partir de certains échantillons de données. (Par exemple, si la distribution de la population est normale, les paramètres sont la moyenne et l'écart type.) Ici, nous considérons également un intervalle de confiance en utilisant l'erreur standard dérivée lors de l'estimation des paramètres.

En passant, je vais omettre les détails sur la façon de dériver l'erreur standard, Lorsque les paramètres sont estimés par la méthode la plus probable, si vous jouez avec la fonction de vraisemblance logarithmique de différentes manières (différencier, prendre la valeur attendue, etc.) L'erreur standard peut être dérivée.

Compte tenu de l'intervalle de confiance à 95% (= paramètre estimé +/- 2 x erreur standard) Répétez 100 fois l'estimation de l'intervalle de confiance à 95% ci-dessus avec de nouveaux échantillons de données échantillonnés à partir de la distribution de la population.

Après 100 essais, 95 fois incluent la valeur réelle du paramètre de distribution de la population dans l'intervalle de confiance à 95%, et 5 fois non. L'erreur standard est utilisée dans le sens ci-dessus. En gros, c'est comme un indicateur de la fiabilité des paramètres estimés.

Un terme similaire est l'écart type σ, qui fait référence à la distribution dans laquelle les données peuvent effectivement être combinées.

Différence entre l'erreur standard et l'écart type

L'erreur standard est un indice de la fiabilité des données et l'écart type est la plage que les données peuvent prendre. Revenons maintenant au premier titre. J'ai souvent utilisé la formule de propagation d'erreur pour l'écart type (ou erreur), mais ce que je me demandais cette fois était "Peut-il être appliqué aux erreurs standard?" Je pensais qu'il n'y aurait pas de problème si je l'appliquais tel quel, mais j'ai essayé la simulation numérique avec soin.

J'ai essayé une simulation numérique

En tant que flux, (1) Estimer les paramètres a, b et c par la méthode la plus probable en générant des données selon ce qui suit. Où ε est un bruit aléatoire normalement distribué.

y = a+bx^2+cx^{-2} + ε

(2) Une fois que b et c peuvent être estimés, calculez le paramètre d = (c / b) ^ (1/4). (3) Calculez l'erreur standard de d à partir des erreurs standard de b et c en utilisant la formule de propagation d'erreur. 　 Répétez les étapes ①②③ plusieurs fois et considérez que la variation de d calculée en ② est l'erreur standard de d. Si cela correspond à la valeur calculée dans (3), la formule de propagation d'erreur peut être appliquée à l'erreur standard. Comme plusieurs calculs dans (3) sont également effectués, la valeur moyenne est utilisée.

Vous trouverez ci-dessous le code et la sortie python réels Je pense que la variation de (2) et le résultat du calcul (3) correspondent à peu près.

`main.py`


import numpy as np
from numpy.random import *
from scipy.optimize import curve_fit
import statistics
import math


def create_toydata(x_list):
    """
    x_avec liste comme argument,Y avec erreur_Créer une liste
    :param x_list:Liste de x
    :return y_list:Liste de y fonction de x
    :return true_d:Vrai d
    """

    #Valeur vraie du paramètre Le nombre est approprié
    a = 2e2
    b = 2e-5
    c = 2e7

    y_list = [None] * len(x_list)

    for i, x in enumerate(x_list):
        #Ajoutez une erreur de distribution normale aux données. Le numéro 2 a été décidé de manière appropriée
        noize = 2 * randn()
        y_list[i] = func(x, a, b, c) + noize

    # c,Calculer d, qui est une fonction de b
    true_d = (c/b)**(1/4)

    return y_list, true_d


def func(x, a, b, c):
    """Définissez une fonction à adapter. La fonction elle-même a été décidée de manière appropriée"""
    return a + b * x**2 + c * x**(-2)


def cal_se(C, B, C_se, B_se, COV):
    """
De la loi de propagation d'erreur lorsqu'il y a corrélation(C/B)^(1/4)Trouvez l'erreur de
    :param C:Paramètre C
    :param B:Paramètre B
    :param C_se:Erreur standard C
    :param B_se:Erreur standard de B
    :param COV: C,Covariance B
    :return: (C/B)^(1/4)Erreur standard
    """
    del_c = (1/4) * C**(-3/4) * B**(-1/4)
    del_b = (-1/4) * C**(1/4) * B**(-5/4)

    return math.sqrt((del_c* C_se)**2 + (del_b * B_se)**2 + 2 * COV * del_c * del_b)


if __name__ == '__main__':

    #Nombre d'essais
    n = 1000

    a_list = [None] * len(range(n))
    b_list = [None] * len(range(n))
    c_list = [None] * len(range(n))
    d_list = [None] * len(range(n))
    d_se_list = [None] * len(range(n))

    # cnt:95%Le nombre de valeurs vraies dans l'intervalle de confiance
    cnt = 0

    #Répétez l'essai suivant n fois
    for i in range(n):
        #De toydata, "y" par la méthode la plus probable= a + x^2 + c^-2 "coefficient a,b,Trouver c
        # b,Calculez d, qui est une fonction de c.
        # b,Calculez l'erreur standard de d à partir de l'erreur standard de c.

        #Les chiffres sont appropriés
        x_st = 500
        x_end = 2500
        x_num = 200

        x_list = np.linspace(x_st, x_end, x_num).tolist()
        y_list, true_d = create_toydata(x_list=x_list)

        popt, pcov = curve_fit(func, x_list, y_list)

        # #Calculer d
        d = (popt[2]/popt[1])**(1/4)
        d_list[i] = d

        #L'erreur standard de d,b,Calculer à partir de l'erreur standard de c
        d_se = cal_se(popt[2], popt[1], math.sqrt(pcov[2][2]), math.sqrt(pcov[1][1]), pcov[1][2])
        d_se_list[i] = d_se

        # 95%Trouvez l'intervalle de confiance
        d_low, d_up = d - 2 * d_se, d + 2 * d_se

        # 95%Vérifiez le nombre de fois où la valeur vraie est entrée dans l'intervalle de confiance
        if d_low < true_d and true_d < d_up:
            cnt += 1


    #Trouvez l'écart type de d essayé n fois(Considérez cela comme l'erreur standard de d)
    true_d_se = statistics.pstdev(d_list)
    print("Erreur standard de d:", true_d_se)

    #L'erreur standard de d est calculée pour chaque nombre d'essais, de sorte que le résultat final est moyenné.
    cal_d_se = statistics.mean(d_se_list)
    print("Moyenne de l'erreur standard calculée de d:", cal_d_se)

    # 95%Découvrez le taux auquel l'erreur standard se situe dans l'intervalle de confiance.95%0 à partir de la définition de l'intervalle de confiance.Devrait être 95
    print("95%Pourcentage d'erreurs standard dans l'intervalle de confiance:", cnt/n)

Voici le résultat de l'exécution. La première ligne est la variation de ② et la deuxième ligne est le résultat du calcul de ③.

Erreur standard de d: 2.2655785060979126
Moyenne de l'erreur standard calculée de d: 2.2443534560700673
95%Pourcentage d'erreurs standard dans l'intervalle de confiance: 0.947