Discussion :

[darkwhite]

Bonjour à tous,
J'essaie de réaliser un algo inspiré du passage de l'article suivant :

We have devised a new local adaptive detrending algorithm with these properties. It first partitions a time series into segments (or windows) of length 2n + 1 points, where neighboring segments overlap by n+1 points. For each segment, we fit a best polynomial of order K.Denote the fitted
polynomials for the ith and (i+1)th segments by y(i)(l1), y(i+1)(l2), l1, l2 = 1, . . . , 2n+1,
respectively. Note that the length of the last segment may be smaller than 2n + 1. We define the trend for the overlapped region as

y(c)(l)=(1-(l-1)/n)*y(i)(l+n) + (l-1)/n*y(i+1)(l), l=1,2,..,n+1

En fait on recouvre le signal par des segments de taille M=2n+1. Et chaque segments recouvre son voisin sur n+1 points.
Ensuite on crée le polynome Yc sur chaque intersection.
Ce qui m’étonne (voir m’énerve) c'est qu'au final le polynôme Yc que j'obtiens est plus long que le signal de base... Alors que normalement, avec la division euclidienne on devrait tomber sur une taille au moins plus petite.

Voici mon code :

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
load 'input.mat'
n=50;
M=2*n+1;
 
Nseg=floor((length(input)-(2*n+1))/n);
 
K=2;
x=1:M;%taille d'un segment y
l=1:n+1;%taille d'un segments de recouvrement Yc
 
for i=1:Nseg
    seg(i,:)=input(1+(i-1)*n:(i-1)*n+M);
    P=polyfit(x,seg(i,:),K);
    y(i,:)=polyval(P,x);
end
 
%On construit 'the trend for the overlapped region' 
%Il s'applique sur chaque intersections de deux segments
 
for i=1:Nseg-1
Yc(i,l)=y(i,l+n).*(1-(l-1)/n)+y(i+1,l).*(l-1)/n;
end

seg : les segments qui recouvrent le signal input
y : estimation polynomiale sur chaque segment
Yc: estimation polynomiale sur les intersections de chaque segments

cependant la taille de Yc est plus grande que input ...

En gambergeant j'ai essayé de recenser
les points en trop:
*Le dernier point du ieme segment correspond au premier point du i+2e segment si on est d'accord.
les points qui manquent:
*Les L points constitués du nombre de points entre la fin du dernier segments et le nombre de point du signal.

Cependant ça ne fait pas le compte.

Voilà si vous avez la patience pour vous prendre la tête sur un problème de dénombrement comme celui là je vous serais extrêmement reconnaissant, sinon bonsoir !.
ps: je n'ai pas trouvé de balise latex, j'espere que c'est pas trop crade.

[tachmou]

Bonjour,

Je n'ai pas tout bien lu dans le détail, mais que contient "input" stp ? Peux-tu faire un size(input) et donner la valeur ici stp. J'ai l'impression que tu travailles sur des tableaux alors qu'à la base tu utilises "length" qui te renvoies la taille d'une liste et non d'un tableau...

Par ailleurs, es-tu sûr de tes définitions de "x" et de "l" dans ton programme ? Tu dis en commentaire qu'ils contiennent des tailles alors que pour moi ce sont des listes allant de 1 à la taille dont tu parles...

Quoiqu'il en soit, avant de travailler sur des tableaux de dimension mxn, je te conseilles de travailler sur des listes de tailles 1xn...

Ce n'est pas du chipotage : j'essaye de comprendre ton programme... et comme je ne suis pas du domaine, bah je pige rien :/ En effet, sur les lignes dont je parle, je ne sais pas ce qui est juste : tableau ou liste ? Liste ou valeur ? Du coup, ça donne l'impression que tu te contredis sur la même ligne haha

Essaye de proposer un code complet en corrigeant ces "petits" détails... ça nous permettra de comprendre plus facilement, et peut-être que ça te permettra de te rendre compte de certaines erreurs par toi-même

Cordialement,

[darkwhite]

Bonjour,
En tout cas merci de t'interesser à mon problème ...
Input est un signal colonne de 800 points :

Code :

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

1
2
3
size(input)
ans =
   800     1

x et l sont inspiré du texte en anglais. x est l'index de tout polynome y
car on a dans l'article y(l1) avec l1=1,2,..,2*n+1=M ici l1=x. De même l correspond à l'index de tout polynome Yc car on a Yc(l) avec l=1,2,3,..,n.
Effectivement, le terme de taille est mal choisit.

Quoiqu'il en soit, avant de travailler sur des tableaux de dimension mxn, je te conseilles de travailler sur des listes de tailles 1xn...

A quel niveau ? pour stocker les y ? je ne vois pas vraimment comment faire avec un seul vecteur. La base du problème est de decouper un signal en signal de 2n+1 points. Mais chaque segment recouvre son voisin à moitié (n+1 points). J'ai mis un schema rapide pour décrire.


http://hpics.li/be67722
Voilà si ya besoin de plus de précisions j'en donne plus !

[tachmou]

Okay, merci, j'avais un doute. En ce qui concerne ma dernière remarque, je pensais justement que ton tableau était de taille mxn (genre tu voulais traiter plusieurs signaux en parallèle)... donc ton length renvoyait totalement autre chose et que par la suite ça devenait n'importe quoi... sachant que je pensais que pour toi la taille se stockait dans une liste : je n'ai pas cherché plus loin. Bref j'étais à l'ouest : comme quoi ces "détails" peuvent mener loin ^^

Peux-tu donc poster un code en corrigeant ces détails et en commentant un poil plus (en étant rigoureux donc). Juste cette étape permettra à d'autres de comprendre plus facilement. Y compris moi

Conseil perso : x, tu peux le renommer index_segment ou i_segment ou i_seg et l tu peux le renommer index_recouvrement... ça parle plus. Cela alourdit le code mais peut le rendre tellement plus compréhensible. A titre informatif, j'ai développé des codes de près de 10 000 lignes... dont 8 000 de commentaires ==> soit 2 000 seulement, mais tellement efficaces et faciles à lire/relire/corriger, que ce soit immédiatement ou dans plusieurs années quand tu auras tout oublié ^^ Je pense notamment à certaines petites fonctions qui font à peine 5 lignes de code mais carrément près d'une centaine de commentaire

Bref, tu n'es pas obligé de suivre tous mes conseils hein mais reposte au moins un code concis, clair et sans ambiguïté.

[darkwhite]

Merci, je comprends tout à fait les raison des commentaires.
Voici le code plus commenté:

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
44
45
 
clc;
close all;
clear all;
 
 
load 'input.mat'
 
n=4;
%Taille d'un segment
M=2*n+1;
 
%Nombre de segments de taille M qui recouvrent le signal
%et qui ont n+1 points en commun
Nseg=floor(length(input)/n)-1;
 
 
K=2;%Degre du polynome y
index_y=1:M;%axe des abscisse de chaque polynome y
index_yc=1:n+1;%axe de abscisse de chaque Yc
 
 
B=[];
for i=1:Nseg
    %On extrait un segment de taille M du signal
    seg(i,:)=input(1+(i-1)*n:(i-1)*n+M);
    %On cherche le polynome de degré K qui correspond
    P=polyfit(index_y,seg(i,:),K);
    y(i,:)=polyval(P,index_y);
 
end
 
%On met tous les segments sous forme d'un vecteur
B=reshape(y',1,size(y,1).*size(y,2));
 
A=[];
for i=1:Nseg-1
%D'apres l'article, on calcule la valeur de Yc sur les 
%abscisses correspondant aux intersections de chaque segment
 
Yc(i,index_yc)=y(i,index_yc+n).*(1-(index_yc-1)/n)+y(i+1,index_yc).*(index_yc-1)/n;
end
 
%Mise des Yc sous forme d'un seul vecteur
A=reshape(Yc',1,size(Yc,1).*size(Yc,2))';

En relisant mon code j'ai changé 2/3 ça ne compile plus. J'ai des problèmes de taille. Merci de votre aide, mais je pense qu'en fait le soucis vient que je sais pas bien compter....
Il faut bien calculer la valeur de Nseg: le nombre de segment de taille 2n+1 que l'on peut mettre dans un axe de longueur length(input) et dont chaque segment recouvrement la moitié (n+1 points) de son voisin de droite et est recouvert par la moitié de son voisin de gauche (n+1 points).

[tachmou]

Ah, c'est déjà bien plus clair !

Bon, je me suis permis d'apporter quelques modifications

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
44
45
46
47
48
49
50
51
52
53
54
55
clc;
close all;
clear all;

% Input
input = [];
load 'input.mat'
% input est de taille 800x1

n=4;

% Taille d'un segment
M=2*n+1;

% Nombre de segments de taille M qui recouvrent le signal
% et qui ont n+1 points en commun
Nseg=floor((length(input)-(n+1))/n)-1;

% Degre du polynome y
K=2;

% Index de l'axe des abscisse de chaque polynôme y
index_y=1:M;

% Index de l'axe des abcsisse de chaque Yc
index_yc=1:n+1;


B=[];

for i=1:Nseg
    % On extrait un segment de taille M du signal
    seg(i,:)=input(1+(i-1)*n:(i-1)*n+M);

    % On cherche le polynome de degré K qui correspond
    P=polyfit(index_y,seg(i,:),K);
    y(i,:)=polyval(P,index_y);
end

%On met tous les segments sous forme d'un vecteur
B=reshape(y',1,size(y,1).*size(y,2));

A=[];

for i=1:Nseg-1
    % D'apres l'article, on calcule la valeur de Yc sur les 
    % abscisses correspondant aux intersections de chaque segment
    % y(c)(l)=(1-(l-1)/n)*y(i)(l+n) + (l-1)/n*y(i+1)(l), l=1,2,..,n+1

    Yc(i,index_yc)=y(i,index_yc+n).*(1-(index_yc-1)/n)+y(i+1,index_yc).*(index_yc-1)/n;
end

%Mise des Yc sous forme d'un seul vecteur
A=reshape(Yc',1,size(Yc,1).*size(Yc,2))';

(==> pas testé, je n'ai pas matlab sous la main en ce moment)

Pas la peine de mettre sous forme de vecteur : ta première méthode était bonne... quand je te disais de travailler sur des séries à une dimension, je voulais parler de ton "input" car à la base j'avais peur que justement tu travaillais sur plusieurs séries en même temps ^^'

Quelles sont les erreurs dont tu parles ?

Par ailleurs, maintenant je peux comprendre ta remarque du début :

Ce qui m’étonne (voir m’énerve) c'est qu'au final le polynôme Yc que j'obtiens est plus long que le signal de base... Alors que normalement, avec la division euclidienne on devrait tomber sur une taille au moins plus petite.

==> Je ne sais pas d'où tu sort ce "normalement", mais pour moi cette vérité est ... fausse ! Si on fait un calcul "à la louche" : Nseg*(n+1) > Nseg*n ! (Attention, ceci n'est vrai qu'à condition d'avoir beaucoup de découpe, bien sûr... sinon ça peut être effectivement plus petit dans certains cas bien particuliers : quand le reste de la division euclidienne est plus grande que Nseg !) En effet, dans le signal de départ, tes signaux se recouvrent. A la fin, ton signal ne se recouvre pas mais se juxtapose... les "1" se "dédoublent" en quelque sorte...

Du coup, ton code de départ était peut-être juste ... Content d'avoir passé quelques jours pour rien à cause de moi ? N'empêche, comme quoi, ça vaut le coup de prendre le temps de rendre son code et ses explications le plus didactique possible, surtout quand on demande de l'aide, même si on a l'impression qu'on prend les gens pour des c*** si on fait ça : c'est tout le contraire en fait, donc il ne faut pas hésiter ^^ ! D'ailleurs, bien des fois, en détaillant tranquillement tout, on trouve l'erreur soi-même très rapidement du coup... et si on ne la trouve pas, elle devient évidente pour un individu lambda ==> tout bénéf!

J'espère que ça répond à tes questions

ps: je ne suis pas très fan des ".*", même si ça allège énormément le code, je trouve que ça le rend plus difficilement lisible... du moins c'est plus difficile de trouver des erreurs de calculs avec... mais là, ça me semble juste.