[DEBUTANT PYTHON] aidez moi les kheys

Salut les kheys

Je viens de faire un code python qui fonctionne bien mais qui est beaucoup trop long en temps d'exécution par rapport à ce que ça devrait. Je pense que des kheys chauds en python pourraient m'aider à le faire aller plus vite.

Le but c'est d'utiliser une méthode d'éléments finis "stochastiques" pour calculer un potentiel électrique. Si des kheys sont chauds de m'expliquer ce que je pourrais optimiser dans cette fonction vous me rendriez un ENORME service. Je vous donne des infos en plus sur les maths derrière mais c'est plus un souci d'optimisation au niveau des boucles qui me gène.

Infos supplémentaires au cas où : EFS.binomial donne les coefficients binomiaux, EFS.liste2D(p) donne deux listes de uplets dont j'ai besoin pour mes fonctions, EFS.hermite_MD renvoie le polynôme d'Hermite M-dimensionnel évalué aux Ti, les Ti sont les points de Gauss et EF.resol_2D renvoie la valeur du potentiel électrique en chaque point du maillage.

Le code :

def MMC_2D(N, p, eps1, eps2, M=2):

    start = time.time()

    # =================== PARAMETRES HORS BOUCLE ===================#

    delta = 1e-8

    # Degré maximum du polynôme d'Hermite
    P = int(EFS.binomial(p, M + p))

    # Liste des uplets utilisés pour définir les polynômes de Hermite
    L, L_den = EFS.listes2D(p)

    # Nombre de noeuds
    Nn = N ** 2

    # Obtention du maillage
    points, triangles = EF.Del(N)
    X = np.linspace(0, 10, N)
    Y = np.linspace(0, 10, N)

    # Initialisation des listes pour stocker les résultats
    A_total = np.zeros((0, P))  # Initialisation de la matrice pour A
    gamma_total = np.zeros((0, Nn))  # Initialisation de la matrice pour gamma
    V_total = []

    # =================== CHOIX DE LA LOI, ici log-normale ===================#

    ec1 = 10
    m1 = np.log(eps1) - 1 / 2 * np.log(1 + (ec1 / eps1) ** 2)
    v1 = np.log(1 + (ec1 / eps1) ** 2)
    s1 = np.sqrt(v1)

    ec2 = 30
    m2 = np.log(eps2) - 1 / 2 * np.log(1 + (ec2 / eps2) ** 2)
    v2 = np.log(1 + (ec2 / eps2) ** 2)
    s2 = np.sqrt(v2)

    # =================== PARAMETRES DANS LA BOUCLE ===================#

    for n in range(1, N + 1):
        # Initialisation de la matrice A et du vecteur gamma
        A = np.zeros((n ** 2, P))
        gamma = np.zeros((n, N))

        # Calcul des points de Gauss (Correspondant aux Epsilon)
        Ti, _ = roots_hermitenorm(n)

        # Initialisation de la liste pour stocker les valeurs de gamma
        u_NP_i = []

        # Calcul des valeurs u_NP^{(i)} pour chaque paire de points
        for i1 in range(n):
            for i2 in range(n):
                eps1g = sum([s1 ** k / np.math.factorial(k) * np.exp(m1 + (s1 ** 2) / 2) * EFS.hermite_MD(M, L[k], [Ti[i1], Ti[i2]]) for k in range(P)])
                eps2g = sum([s2 ** k / np.math.factorial(k) * np.exp(m2 + (s2 ** 2) / 2) * EFS.hermite_MD(M, L[k], [Ti[i1], Ti[i2]]) for k in range(P)])
                u_det = EF.resol_2D_3(points, triangles, eps1g, eps2g)
                u_NP_i.append(u_det)

            # Concaténation des listes en une seule matrice
            gamma = np.array(u_NP_i)

        # Construction de la matrice A
        for j in range(P):
            for i1 in range(n):
                for i2 in range(n):
                    Psi_j = EFS.hermite_MD(M, L[j], [Ti[i1], Ti[i2]])
                    A[i2 * n + i1, j] = Psi_j

        # Ajout du vecteur gamma et de la matrice A aux totaux
        gamma_total = np.vstack((gamma_total, gamma))
        A_total = np.vstack((A_total, A))

    # Calcul de u_tilde
    A_inv = np.linalg.pinv(A_total)
    u_tilde = np.dot(A_inv, gamma_total)

    # Initialisation des matrices de potentiel et du moment d'ordre 2
    Var = np.zeros((N, N))
    V = np.zeros((N, N))

    # Calcul du potentiel et du moment d'ordre 2
    for k in range(Nn):

        x, y = points[k]
        i = np.where(np.abs(X - x) <= delta)[0][0]
        j = np.where(np.abs(Y - y) <= delta)[0][0]
        V[i][j] = u_tilde[0, k]
        Var[i][j] = sum([u_tilde[l, k] ** 2 * L_den[l] for l in range(P)])

    T_MMC = time.time() - start

    return V, Var, T_MMC

Le 30 avril 2024 à 09:57:18 :
Boucle ne feedez pas

c'est mon littéralement mon premier topic

Rajoute cette ligne à la fin;

P (o) S [t] = o - u = [C] -a N (c) E -R

Le 30 avril 2024 à 10:00:06 :
Rajoute cette ligne à la fin;

P (o) S [t] = o - u = [C] -a N (c) E -R

Le 30 avril 2024 à 10:00:06 :
Rajoute cette ligne à la fin;

P (o) S [t] = o - u = [C] -a N (c) E -R

J'ai pas la ref malheureusement

Le 30 avril 2024 à 10:01:15 :
illisible, refais-le en haskell

C'est quoi ?

Le 30 avril 2024 à 10:02:18 :
Ton problème vu le code c'est sûrement les boucles 'for' imbriquées qui donnent une complexité de fou
Sinon flemme, utilise ChatGPT tu auras directement ta réponse

ChatGPT ne m'aide pas du tout malheureusement

fais au moins du profiling sur ton code pour voir si une boucle en particulier prend beaucoup plus de temps que les autres

après je comprends pas tes maths mais quand tu peux utilise numpy au lieu de faire des boucles

Le 30 avril 2024 à 10:16:14 :
fais au moins du profiling sur ton code pour voir si une boucle en particulier prend beaucoup plus de temps que les autres

après je comprends pas tes maths mais quand tu peux utilise numpy au lieu de faire des boucles

Je débute juste en python Comment on fait ?

[10:18:10] <FarandoleDeCaca>

Le 30 avril 2024 à 10:16:14 :
fais au moins du profiling sur ton code pour voir si une boucle en particulier prend beaucoup plus de temps que les autres

après je comprends pas tes maths mais quand tu peux utilise numpy au lieu de faire des boucles

Je débute juste en python Comment on fait ?

Tu le veux salement ton topic rouge

Le 30 avril 2024 à 10:18:10 :

Le 30 avril 2024 à 10:16:14 :
fais au moins du profiling sur ton code pour voir si une boucle en particulier prend beaucoup plus de temps que les autres

après je comprends pas tes maths mais quand tu peux utilise numpy au lieu de faire des boucles

Je débute juste en python Comment on fait ?

je sais plus je fais que du C et du haskell mais tu dois trouver facilement c'est le langage le plus populaire

Le 30 avril 2024 à 10:19:03 :

[10:18:10] <FarandoleDeCaca>

Le 30 avril 2024 à 10:16:14 :
fais au moins du profiling sur ton code pour voir si une boucle en particulier prend beaucoup plus de temps que les autres

après je comprends pas tes maths mais quand tu peux utilise numpy au lieu de faire des boucles

Je débute juste en python Comment on fait ?

Tu le veux salement ton topic rouge

Je suis sur un secondaire qui s'appelle FarandoleDeCaca qu'est ce que j'en ai à foutre d'avoir un topic rouge ? Si je voulais un topic rouge j'aurai fait un fake cuck au lieu de me faire chier à ramener un code python ici

[10:20:34] <FarandoleDeCaca>

Le 30 avril 2024 à 10:19:03 :

[10:18:10] <FarandoleDeCaca>

Le 30 avril 2024 à 10:16:14 :
fais au moins du profiling sur ton code pour voir si une boucle en particulier prend beaucoup plus de temps que les autres

après je comprends pas tes maths mais quand tu peux utilise numpy au lieu de faire des boucles

Je débute juste en python Comment on fait ?

Tu le veux salement ton topic rouge

Je suis sur un secondaire qui s'appelle FarandoleDeCaca qu'est ce que j'en ai à foutre d'avoir un topic rouge ? Si je voulais un topic rouge j'aurai fait un fake cuck au lieu de me faire chier à ramener un code python ici

Arrête de t'inventer une vie le chômeur