Discussion :

[v.san]

Bonjour,

Je suis en train de travailler sur un oscillateur harmonique. J'ai une liste de données ( temps mesuré et voltage qui indique la position de manière analogique bref j'abrège fortement)
je veux faire un programme python pour traiter un document EXCEL sous pandas (python 3).

Mon problème : j'ai deux colonnes de nombres

Exemples Fictifs:

[mesures]	[données]
1	0,01
2	0.02
3	4
4	0.02
5	3
6	4
7	0
8	3
9	0.02
10	0.01

Ce que je veux faire c'est de dupliquer les nombres qui sont le plus proche de 0 ou 0 de la colonne [données] pour les mettre dans un nouvelle colonne à droite [données proches de zéro] .
les données proche de 0 correspondent au creux ou au ventre des courbes de l'oscillation de mon appareil et je dois chercher ces périodes d'oscillation pour voir comment le pendule évolue avec le temps ( les oscillations du pendule perdent en amplitude à chaque battement et je dois calculer la perte d'énergie du pendule. Je n'ai donc pas le pas / fréquence où mes données seront à 0 et ces chiffres évoluent avec le temps).
Je veux donc faire un programme qui va chercher les données proches ou égal à zéro mais qui soient éloigné entre elles sans connaître exactement cet éloignement de manière précis.
Pour illustrer j'utilise l'exemple au dessus.
Je veux que le programme prennent la mesure 1 = 0.01 et qu'il ne prenne pas la mesure 2 = 0.02 , puis qu'il prenne la mesure 4 = 0.02 et la mesure 10=0.01 sans la mesure 9 = 0.02. tout en restant sur les mêmes lignes

En gros output :

[mesures]	[données]	[Données proches de 0]
1	0,01	0.01
2	0.02
3	4
4	0.02	0.02
5	3
6	4
7	0
8	3
9	0.02
10	0.01	0.01

En sachant que mon tableau contient 2000 mesures et qu'il est possible que des mesures identiques toutes proche ou égal à 0 peuvent être très proches ( en amont et en aval).


j'aimerais surtout des conseils sur la manière à procéder pour la sélection des nombres ciblés.

J'espère être suffisamment clair dans mes explications ( et je m'excuse pour mon magnifique tableau hahaha) .
(je précise aussi que je suis débutant sur python et que c'est mon premier projet personnel sous python)



En vous remerciant d'avance pour votre aide !

[wiztricks]

Salut,

je veux faire un programme python pour traiter un document EXCEL sous pandas (python 3).

Une fois que les données lues avec pandas, quel est l'importance de savoir d'où elle viennent? Vos questions portent sur ce que vous allez faire avec le dataframe panda.

Pour illustrer j'utilise l'exemple au dessus.
Je veux que le programme prennent la mesure 1 = 0.01 et qu'il ne prenne pas la mesure 2 = 0.02 , puis qu'il prenne la mesure 4 = 0.02 et la mesure 10=0.01 sans la mesure 9 = 0.02. tout en restant sur les mêmes lignes

J'espère que cela en inspirera d'autres! Je ne peux que vous conseiller de simplifier, clarifier,...
Partez de la liste D de vos mesures: D = [ 0.01, 0.02, 4, 0.02, 3, 4, 0, 3, 0.02, 0.01 ]
Et racontez comment vous allez construire une liste R satisfaisant vos critères et montrez le code correspondant.

- W

[v.san]

Salut,


J'espère que cela en inspirera d'autres! Je ne peux que vous conseiller de simplifier, clarifier,...
Partez de la liste D de vos mesures: D = [ 0.01, 0.02, 4, 0.02, 3, 4, 0, 3, 0.02, 0.01 ]
Et racontez comment vous allez construire une liste R satisfaisant vos critères et montrez le code correspondant.

- W

Merci pour vos conseils: Cet exercice me fait réfléchir !

Le raisonnement de manière littérale :

j'aimerais qu'il itère sur chaque élément de la liste pour qu'il retienne la valeur la plus proche de 0 , à chaque fois qu'il trouve une nouvelle valeur plus proche de 0 il remplace l'ancienne valeur par la nouvelle.
Quand le nombre recommence à s'éloigner de 0 ( que ce soit de manière positive ou négative vu que j'ai des nombres positifs et négatifs dans mon tableau) il envoie l'ancienne valeur dans la nouvelle liste R et recommence à stocker temporairement la nouvelle valeur proche de 0 on continuant de la remplacer par les nouvelles valeurs plus proche de zéro jusqu’à ce qu'il recommence à s'éloigner.

le problème c'est que je ne sais pas ce que je dois utiliser pour traduire " le plus proche d'une valeur". (je n'ai fais que principalement du texte avec Python)


Je peux mettre tous les termes en valeur absolue et dès que le nombre suivant B redevient plus grand que le nombre suivant A, il envoie A avec son signe d'origine dans la nouvelle liste R ? Pour que les valeurs soient dans le même ordre que les mesures à chaque fois qu'un nombre n'est pas envoyé dans la nouvelle liste R il envoie une valeur 0 à la place.

Est-ce que je suis sur le bon chemin ?

[wiztricks]

Salut,

Est-ce que je suis sur le bon chemin ?

Aucune idée, l'important c'est le voyage non?

Plus sérieusement, c'est vous qui savez ce que vous voulez obtenir (comment remplir R).
Tant que vous n'arrivez pas à décrire les étapes successives à réaliser (en français) pour remplir R, impossible de coder.

v.san;11415669]le problème c'est que je ne sais pas ce que je dois utiliser pour traduire " le plus proche d'une valeur". (je n'ai fais que principalement du texte avec Python)

Soit V la valeur et D l'ensemble de départ, rien ne vous empêche d'imaginer une fonction ppv prenant V et D en argument pour retourner votre nombre. Si au départ vous ne savez pas l'écrire, vous pouvez imaginer ce que devrait par exemple retourner ppv(0.01, D), ppv(4, D),...

Soit çà vous donne des idées sur comment pourrait fonctionner une telle fonction et vous décrivez (en français) les étapes à réaliser pour avoir le résultat. Soit vous n'avez pas encore les idées bien claires et vous pouvez faire comme si cette fonction là était déjà écrite pour voir comment vous allez pouvoir en tirer profit pour construire R.

De toutes façons, vous êtes en train d'essayer de décrire un algorithme. Tant que ce n'est pas fait et que vous n'arrivez pas à le faire fonctionner sur une feuille de papier, inutile de penser à coder quoi que ce soit.

- W

[danielhagnoul]

Je propose le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#! python3
# coding: utf-8
 
import pandas as pd
import numpy as np
 
nb_mesures = 10
limite_minimum = 0.05
 
df = pd.DataFrame({
    'Mesures': [i for i in range(1, nb_mesures+1, 1)],
    'Données': [0.01, 0.02, 4, 0.02, 3, 4, 0, 3, 0.02, 0.01],
    'Minimum': [np.nan for i in range(0, nb_mesures, 1)]
})
 
# print(df)
 
for i in range(len(df)):
    if df.at[i, 'Données'] < limite_minimum:
        minimum = df.at[i, 'Données']
        if i >= 1 and np.isnan(df.at[i-1, 'Minimum']):
            df.at[i, 'Minimum'] = minimum
        elif i >= 1 and df.at[i-1, 'Minimum'] > minimum:
            df.at[i-1, 'Minimum'] = np.nan
            df.at[i, 'Minimum'] = minimum
        elif i == 0:
            df.at[i, 'Minimum'] = minimum
 
print(df)
 
"""
   Mesures  Données  Minimum
0        1     0.01     0.01
1        2     0.02      NaN
2        3     4.00      NaN
3        4     0.02     0.02
4        5     3.00      NaN
5        6     4.00      NaN
6        7     0.00     0.00
7        8     3.00      NaN
8        9     0.02      NaN
9       10     0.01     0.01
"""

[wiztricks]

Salut,

Je propose le code suivant

Si on dit que le problème et de trouver des minima locaux, il y a des constructions pandas bien plus adaptées comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
import pandas as pd
 
D = [0.01, 0.02, 4, 0.02, 3, 4, 0, 3, 0.02, 0.01]
df = pd.DataFrame({
    'M': [i+1 for i in range(len(D))],
    'D': D,
})
print(df)
df['min'] = df.D[(df.D.shift(1) > df.D) & (df.D.shift(-1) > df.D) ]
print(df)

sauf aux extrémités (qui sont des points d'inflexion gérables).

Mais ce n'est pas si clair outre que le PO ne le dit pas et dans le post initial, il y aurait un 0 à la ligne de la mesure '7'.

- W

[danielhagnoul]

@wiztricks : merci d'avoir partagé vos connaissances. On trouve shiht dans la documentation, mais l'écriture df.D[(df.D.shift(1) > df.D) & (df.D.shift(-1) > df.D) ] ?

J'ignorai l'existence de la méthode shift et de cette écriture booléenne pour générer une nouvelle liste à partir d'une liste existante. Il m'a fallu réfléchir et tester progressivement pour bien assimiler votre exemple.

Aucun problème pour trouver les minimas et les maximas de notre jeu de données, mais je ne trouve que deux maximas au lieu de trois en testant sur une sinusoïde.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#! python3
# coding: utf-8
 
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd
 
x = np.linspace(0, 5.0*np.pi, 200)
y = [np.sin(item) for item in x]
 
plt.title("Sin(x)")
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('y')
plt.show()
 
""" Il y a 3 maximums et 2 minimums """
 
df = pd.DataFrame({'x': x, 'y': y})
 
df['Minimums'] = df['y'][(df['y'].shift(1) > df['y']) & (
    df['y'].shift(-1) > df['y'])]
 
df['Maximums'] = df['y'][(df['y'].shift(1) < df['y']) & (
    df['y'].shift(-1) < df['y'])]
 
pd.options.display.max_rows = 999
print(df)
 
""" Il n'y a que 2 maximums au lieu de 3 """

[wiztricks]

Aucun problème pour trouver les minimas et les maximas de notre jeu de données, mais je ne trouve que deux maximas au lieu de trois en testant sur une sinusoïde.

Mon code devrait être bug compatible avec le votre.
Et si on regarde l'algorithme qu'il y a derrière, il détecte les minima lorsque la courbe est en V mais les saute lorsqu'elle est en U.

- W

[danielhagnoul]

@wiztricks : alors que print(np.isclose(df.at[99, 'y'], df.at[100, 'y'])) fonctionne très bien, avec shift(1) cela produit une erreur de type.

J'ai contourné la difficulté en utilisant une valeur epsilon, qu'en pensez-vous ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#! python3
# coding: utf-8
 
from matplotlib import pyplot as plt
from termcolor import cprint
import numpy as np
import pandas as pd
 
x = np.linspace(0, 5.0*np.pi, 200)
y = [np.sin(item) for item in x]
df = pd.DataFrame({'x': x, 'y': y})
 
epsilon = 1e-7
 
df['Minimums'] = df['y'][(df['y'].shift(1) > df['y'] - epsilon) & (
    df['y'].shift(-1) > df['y'] - epsilon)]
 
df['Maximums'] = df['y'][(df['y'].shift(1) < df['y'] + epsilon) & (
    df['y'].shift(-1) < df['y'] + epsilon)]
 
pd.options.display.max_rows = 999
print(df)

[wiztricks]

Salut,

J'ai contourné la difficulté en utilisant une valeur epsilon, qu'en pensez-vous ?

Il ne faut pas penser, mais essayer de comprendre le problème.
Un algo. qui dit que y_n est minimum local si ses voisins immédiats y_n-1 et y_n+1 vérifient y_n-1 > y_n et y_n < y_n+1 est un peu myope.

Il fonctionne si tous les minima sont en V. Avec [3, 2, 1, 2, 3 ] pas de soucis pour sortir le 1.
Mais si on a un U çà le saute: pour [3, 1, 1, 2, 3 ], il verra que dalle.
Ce qui pose aussi la question de savoir comment rendre compte du minimum dans ce cas.

Difficile de rafistoler un algorithme qui ne fonctionne pas à coup d'epsilon: on jette tout et on recommence.

- W

[danielhagnoul]

@wiztricks : je ne suis pas d'accord avec vous pour "jeter le bébé avec l'eau du bain", je crois que l'on bute simplement sur le problème de la vérification de l'équalité de deux réels, d'où ma tentative d'utiliser np.isclose() et le recours à une valeur epsilon.

L'exemple [3, 1, 1, 2, 3 ] ne pose pas de problème [1, 1] est détecté comme le minimum :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#! python3
# coding: utf-8
 
import pandas as pd
import numpy as np
 
nb_mesures = 5
epsilon = 1e-7
 
df = pd.DataFrame({
    'x': [i for i in range(1, nb_mesures+1, 1)],
    'y': [3, 1, 1, 2, 3],
})
 
df['Minimums'] = df['y'][(df['y'].shift(1) > df['y'] - epsilon) & (
    df['y'].shift(-1) > df['y'] - epsilon)]
 
 
print(df)
 
"""
   x  y  Minimums
0  1  3       NaN
1  2  1       1.0
2  3  1       1.0
3  4  2       NaN
4  5  3       NaN
"""

[wiztricks]

Salut,

L'exemple [3, 1, 1, 2, 3 ] ne pose pas de problème [1, 1] est détecté comme le minimum

L'exemple n'est là que pour vous montrer la faiblesse de l'algorithme.
Après si vous bricoler un epsilon là dedans, on peut toujours trouver une suite qui produira des résultats "bizarres".

Si vous voulez un algorithme plus costaud, on peut supposer que l’échantillonnage sort d'une fonction continue et dérivable. Dans ce cas les extrema sont les points où la dérivée s'annule et change de signe (sinon c'est un point d'inflexion).

- W