Exempel på entropi

Proventropi (SampEn) är en modifiering av ungefärlig entropi (ApEn), som används för att bedöma komplexiteten hos fysiologiska tidsseriesignaler, diagnostisera sjukdomstillstånd. SampEn har två fördelar jämfört med ApEn: datalängdsoberoende och en relativt problemfri implementering. Det finns också en liten beräkningsskillnad: I ApEn inkluderar jämförelsen mellan mallvektorn (se nedan) och resten av vektorerna även jämförelse med sig själv. Detta garanterar att sannolikheter $C_{i}'^{m}(r)$ aldrig är noll. Följaktligen är det alltid möjligt att ta en logaritm av sannolikheter. Eftersom malljämförelser med sig själva lägre ApEn-värden, tolkas signalerna som mer regelbundna än de faktiskt är. Dessa självmatcher ingår inte i SampEn. Men eftersom SampEn direkt använder sig av korrelationsintegralerna är det inte ett verkligt mått på information utan en approximation. Grunderna och skillnaderna med ApEn, samt en steg-för-steg handledning för dess applikation finns på.

Det finns också en flerskalig version av SampEn, föreslagen av Costa och andra. SampEn kan användas inom biomedicinsk och biomekanisk forskning, till exempel för att utvärdera postural kontroll.

Definition

Liksom ungefärlig entropi (ApEn), är proventropi ( SampEn ) ett mått på komplexitet . Men det inkluderar inte självliknande mönster som ApEn gör. För en given inbäddningsdimension $m$ , tolerans $r$ och antal datapunkter $N$ , är SampEn den negativa naturliga logaritmen för sannolikheten att om två uppsättningar av samtidiga datapunkter med längd $m$ har avstånd $<r$ då två uppsättningar av samtidiga datapunkter med längden $m+1$ har också avstånd $<r$ . Och vi representerar det med $SampEn(m,r,N)$ (eller med ${\ displaystyle SampEn(m,r,\tau ,N)}$ inklusive samplingstid $\tau$ ).

Antag nu att vi har en tidsseriedatauppsättning med längden $N={\{x_{1},x_{2},x_{3},...,x_{N}\}}$ med ett konstant tidsintervall $\tau$ . Vi definierar en mallvektor med längden $m$ , så att $X_{m}(i)={\{x_{i},x_{i+1},x_{i+2},...,x_{i+m -1}\}}$ och avståndsfunktionen ${\displaystyle d[X_{m}(i),X_{m}(j)]} ($ i≠ j) ska vara Chebyshev-avståndet (men det kan vara vilken avståndsfunktion som helst, inklusive euklidiskt avstånd). Vi definierar proventropin som

SampEn=-\ln {A \over B}

Var

$A$ = antal mallvektorpar som har $d[X_{m+1}(i),X_{ m+1}(j)]<r$

$B$ = antal mallvektorpar som har $d[X_{m}(i),X_{m}(j)] <r$

Det framgår av definitionen att $A$ alltid kommer att ha ett värde som är mindre eller lika med $B$ . Därför kommer $SampEn(m,r,\tau )$ alltid vara antingen noll eller positivt värde. Ett mindre värde på $SampEn$ indikerar också mer självlikhet i datamängden eller mindre brus.

I allmänhet tar vi värdet på $m$ till $2$ och värdet på $r$ till $0,2\times std$ . Där std står för standardavvikelse som bör tas över en mycket stor datamängd. Till exempel är r-värdet på 6 ms lämpligt för entropiberäkningar av pulsintervall, eftersom detta motsvarar $0,2\ gånger std$ för en mycket stor population.

Multiscale SampEn

Definitionen som nämns ovan är ett specialfall av sampEn med flera skalor med $\delta =1$ , där $\delta$ kallas skipping-parameter. I flerskala SampEn-mall definieras vektorer med ett visst intervall mellan dess element, specificerat av värdet på $\delta$ . $X_{m,\delta }(i)={x_{i},x_{i+\delta},x_{i+2\times \delta },. ..,x_{i+(m-1)\ gånger \delta }}$ mallvektor och sampEn kan skrivas som ${\displaystyle SampEn\ left(m,r,\delta \right)=-\ln {A_{\delta } \over B_{\delta }}} Och vi$ beräknar $A_{\delta }$ och $B_{\delta }$ som tidigare.

Genomförande

Exempel på entropi kan enkelt implementeras i många olika programmeringsspråk. Nedan finns ett vektoriserat exempel skrivet i Python.

   

   
    
      
      
      
    
    
                
                  

    
                

    
      
                  

                

    
        importera  numpy  som  np  def  sampen  (  L  ,  m  ,  r  ):  """Sample entropi."""  N  =  len  (  L  )  B  =  0.0  A  =  0.0  # Dela tidsserier och spara alla mallar med längden m  xmi  =  np  .  array  ([  L  [  i  :  i  +  m  ]  för  i  inom  intervallet  (  N  -  m  )])  xmj  =  np  .  array  ([  L  [  i  :  i  +  m  ]  för  i  inom  intervallet  (  N  -  m  +  1  )])  # Spara alla matchningar minus självmatchningen, beräkna B  B  =  np  .  summa  ([  np  .  summa  (  np  .  abs  (  xmii  -  xmj  )  .  max  (  axel  =  1  )  <=  r  )  -  1  för  xmii  i  xmi  ])  # Liknande för beräkning av A  m  +=  1  xm  =  np  .  array  ([  L  [  i  :  i  +  m  ]  för  i  inom  intervallet  (  N  -  m  +  1  )])  A  =  np  .  summa  ([  np  .  summa  (  np  .  abs  (  xmi  -  xm  )  .  max  (  axel  =  1  )  <=  r  )  -  1  för  xmi  i  xm  ])  # Return SampEn  retur  -  np  .  log  (  A  /  B  )

Ett exempel skrivet på andra språk finns:

Matlab
R .

Se även