Skip to content

Archive

Category: Matlab

Criteria for detection of transiently evoked otoacoustic emissions in schoolchildren
Bartosz Trzaskowski, Edyta Pilka, W. Wiktor Jedrzejczak, Henryk Skarzynski
International Journal of Pediatric Otorhinolaryngology 79 (2015), pp. 1455-1461
http://www.sciencedirect.com/science/article/pii/S0165587615003043

Objectives
The aim was to compare, on the same dataset, existing detection criteria for transiently evoked otoacoustic emissions (TEOAEs) and to select those most suitable for use with school-aged children.

Methods
TEOAEs were recorded from the ears of 187 schoolchildren (age 8–10 years) using the Otodynamics ILO 292 system with a standard click stimulus of 80 dB peSPL. Pure tone audiometry and tympanometry were also conducted. Global and half-octave-band (at 1, 1.4, 2, 2.8, 4 kHz) values of OAE signal-to-noise ratio (SNR), reproducibility, and response level were determined. These parameters were used as criteria for detection of TEOAEs. In total, 21 criteria based on the literature and 3 new ones suggested by the authors were investigated.

Results
Pure tone audiometry and tympanometry screening generated an ear-based failure rate of 7.49%. For TEOAEs, there was a huge variability in failure rate depending on the criteria used. However, three criteria sets produced simultaneous values of sensitivity and specificity above 75%. The first of these criteria was based only on a global reproducibility threshold value above 50%; the second on certain global reproducibility and global response values; and the third involved exceeding a threshold of 50% band reproducibility. The two criteria sets with the best sensitivity were based on global reproducibility, response level, and signal-to-noise ratio (with different thresholds across frequency bands).

Conclusions
TEAOEs can be efficiently used to test the hearing of schoolchildren provided appropriate protocols and criteria sets are used. They are quick, repeatable, and simple to perform, even for nonaudiologically trained personnel. Criteria with high sensitivity (89%) were identified, but they had relatively high referral rates. This is not so much a problem in schoolchildren as it is in newborns because with schoolchildren pure tone audiometry and tympanometry can be performed immediately or at a follow-up session. Nevertheless, high referral rates lead to increased screening cost; for that reason, three less rigorous criteria with high values of both sensitivity and specificity (75% and above) are recommended.

Porównanie algorytmów detekcji fali V w badaniu słuchowych potencjałów wywołanych pnia mózgu Bartosz Trzaskowski
Nowa Audiofonologia 2015; 4(2):43-52

W pracy przedstawione i porównane zostały wybrane systemy automatycznej detekcji słuchowych potencjałów wywołanych pnia mózgu, opisane w czasopismach naukowych przez różne zespoły badawcze.

W czasopiśmie Otorynolaryngologia ukazała się praca przedstawiająca wyniki oceny jakości działania systemu automatycznej detekcji słuchowych potencjałów wywołanych pnia mózgu.

System automatycznej detekcji słuchowych potencjałów wywołanych pnia mózgu.II. Ocena działania systemu dla danych klinicznych.
Bartosz Trzaskowski, Krzysztof Kochanek, W. Wiktor Jędrzejczak, Adam Piłka, Henryk Skarżyński
Otorynolaryngologia, 2013; 12(4): 183-189
http://www.mediton.pl/PL/czasopisma/otorynolaryngologia/archiwum_12.4.0.html

W tym wpisie chciałbym porównać podstawowe cechy dwóch platform do obliczeń naukowych: środowiska Matlab firmy Mathworks i języka Python z dedykowanymi do tego typu zadań bibliotekami. Prosty program obliczający widmo sygnału powinien być odpowiedni do porównania podstawowych cech obu języków, podobieństw i różnic składni, łatwości implementacji, przejrzystości i zrozumiałości kodu.

Poniższy skrypt w języku Matlaba liczy widmową gęstość mocy (PSD) modelowanego sygnału zawierającego dwie składowe harmoniczne o częstotliwościach 30 i 80 Hz. Widmo liczone jest przy wykorzystaniu szybkiej transformaty Fouriera, okienkowanie oknem Hanninga.

tic
 
fs=400; T=10;
 
nfft=512;
overlap=0.5;
 
A1=1; f1=30; fi1=0;
A2=2; f2=80; fi2=2;
An=1.5;
 
t=0:1/fs:T;
t=t(:); % make 't' a column vector
 
sig=A1*cos(2*pi*f1*t+fi1) + A2*cos(2*pi*f2*t+fi2);
noise=An*rand(length(t),1);
 
x=sig+noise;
 
wind=hanning(nfft);
 
noverlap=fix(nfft*overlap);
nadvance=nfft-noverlap;
nrecs=fix((length(t)-noverlap)/nadvance);
 
Pxx=zeros(nfft,1);
ind=1:nfft;
for k=1:nrecs
    xs=x(ind);
    xs=(xs(:)-mean(xs)).*wind;
    Xf=fft(xs,nfft)/nfft;
    Pxx=Pxx+abs(Xf).^2;
    ind=ind+nadvance;
end
 
Pxx=Pxx(1:nfft/2);
f=(0:nfft/2-1)/(nfft/2-1)*(fs/2);
 
figure
plot(f,10*log10(Pxx)) % in dB
xlabel('f [Hz]')
ylabel('PSD [dB]')
saveas(gcf,'fig_PSD_matlab.png','png')
 
% time
czas=toc;
czas_=['Time: ' int2str(fix(czas/3600)) ' hours, ' ...
    int2str(fix(czas/60)-fix(czas/3600)*60) ' min and ' ...
    num2str(mod(czas,60),'%0.2f') ' s.'];
disp(' ');
disp(czas_)

Ten sam program napisany w Pythonie przy wykorzystaniu bibliotek NumPy i Matplotlib wygląda tak:

import numpy, pylab, time
from math import pi
 
tic=time.clock()
 
fs,T=400,10 
 
nfft=512
overlap=0.5
 
A1,f1,fi1 = 1,30,0 
A2,f2,fi2 = 2,80,2 
An=1.5
 
t=numpy.arange(0,T,1./fs)
t=t.transpose()
 
sig=A1*numpy.cos(2*pi*f1*t+fi1) + A2*numpy.cos(2*pi*f2*t+fi2)
noise=An*numpy.random.rand(len(t))
x=sig+noise
 
wind=numpy.hanning(nfft)
 
noverlap=numpy.fix(nfft * overlap)
nadvance=nfft-noverlap
nrecs=numpy.fix((len(t)-noverlap)/nadvance)
 
Pxx=numpy.zeros((nfft))
ind=numpy.arange(0,nfft,1)
for k in range(nrecs):
    xs=x[ind]
    xs=numpy.multiply((xs-numpy.mean(xs)),wind)
    Xf=numpy.fft.fft(xs,nfft)/nfft
    Pxx=Pxx+numpy.square(numpy.abs(Xf))
    ind=ind+int(nadvance)
 
Pxx=Pxx[0:nfft/2]
f=numpy.arange(0.0,nfft/2,1)/(nfft/2-1)*(fs/2)
 
pylab.figure
pylab.plot(f,10*numpy.log10(Pxx),linewidth=0.5) # in dB
pylab.xlabel('f [Hz]')
pylab.ylabel('PSD [dB]')
pylab.savefig("fig_PSD_python.png")  
pylab.show()
 
# time
toc = time.clock()
czas=toc - tic
czas_='Time: '
czas_=czas_ + "%0.*f" %(0,numpy.fix(czas/3600)) + ' hours, '
czas_=czas_ + "%0.*f" %(0,numpy.fix(czas/60)-numpy.fix(czas/3600)*60) + ' min and '
czas_=czas_ + "%0.*f" %(2,numpy.mod(czas,60)) + ' s.'
print(czas_)

Na pierwszy rzut oka widać duże podobieństwo pomiędzy obydwoma programami i wydaje się, że dla użytkownika Matlaba rozpoczęcie pracy z Pythonem przy wykorzystaniu dedykowanych bibliotek powinno być względnie proste. Oba języki są językami wysokiego poziomu, dającymi dużą swobodę w wyborze metody rozwiązania problemu. Biblioteki do obliczeń numerycznych zawierają funkcje o bardzo podobnych nazwach, wywołaniu i działaniu do funkcji znanych użytkownikom Matlaba. Niemniej jednak, po kilku latach używania Matlaba, jest kilka elementów do których się przyzwyczaiłem i których jest mi brak przy pierwszym kontakcie z Pythonem. Na przykład: brak operatorów z kropką wyraźnie określających działania na pojedynczych elementach tablicy, czy przejrzystego i prostego zapisu macierzy w postaci a=[1,2,3;4,5,6].

Poniższy rysunek pokazuje wynik działania funkcji plot() w Matlabie (po lewej) i jej odpowiednika o takiej samej nazwie z biblioteki Matplotlib (po prawej).

Orientacyjny czas wykonania obydwu programów przy kilkukrotnym uruchomieniu jest bardzo zbliżony do siebie. Na przenośnym komputerze z procesorem Intel Core 2 Duo 2GHz wynosi:
Matlab: 0.25 s [0.24-0.26]
Python: 0.26 s [0.25-0.27]

Ciekawostką jest, że wykonanie skryptu Matlaba w środowisku Octave trwało znacznie krócej:
Octave: 0.08 s [0.07-0.09]

Żeby porównać wydajność obu środowisk, należałoby wykonać dużo większą ilość obliczeń. W następnym wpisie przedstawię wyniki takiego zestawienia wykorzystując programy wymagające znacznie większej mocy obliczeniowej.

Ostatnio coraz więcej osób pracujących naukowo, do wykonywania obliczeń numerycznych zaczyna wykorzystywać język Python . Ja również od pewnego czasu zastanawiam się nad przeniesieniem części swojej pracy z Matlaba do Pythona. Na korzyść Pythona przemawia kilka argumentów.

Przede wszystkim jest darmowy. W zestawieniu z kosztem Matlaba jest to istotny argument ponieważ znacząca jest już cena samego środowiska obliczeniowego, a dokupienie opcjonalnych toolboxów dodatkowo zwiększa koszt zakupu platformy Mathworks. Darmowe biblioteki Pythona jak np. NumPy, SciPy, Matplotlib czy IPython zapewniają dużą część funkcjonalności podstawowej wersji Matlaba i niektórych toolboxów.

Po drugie Python jest językiem programowania o interpreterach dostępnych na prawie wszystkie platformy. W wielu systemach, wraz z podstawowymi bibliotekami, jest domyślnie rozprowadzany razem z dystrybucją. Dzięki temu, po zainstalowaniu wymaganych bibliotek, możliwe jest wykonanie programów napisanych w Pythonie na prawie każdym komputerze. Natomiast środowisko Matlab, głównie ze względu na swój koszt, jest kupowane najczęściej przez instytucje naukowe, uczelnie lub duże firmy. I przeważnie z licencją na ograniczoną, niewielką liczbę stanowisk lub równoczesnych sesji. Dlatego w Matlabie, programy uruchomić będą mogły tylko osoby mające dostęp do tego środowiska, najczęściej w pracy lub na uczelni. W tym miejscu należałoby wspomnieć o darmowej alternatywie dla programów napisanych w języku Matlaba – platformie Octave. Język Octave jest prawie całkowicie zgodny z językiem Matlaba, a wszelkie różnice w składni i działaniu poszczególnych funkcji są uważane za błędy i systematycznie likwidowane. Jednak obie platformy nie są jeszcze w 100% zgodne ze sobą [Porting programs from Matlab to Octave] i o ile prostsze programy Matlaba bez problemu dają się uruchomić w Octave, to z wykonaniem bardziej skomplikowanych skryptów mogą wystąpić trudności. Umieszczone na tej stronie, proste skrypty w języku Matlaba powinny uruchamiać się w środowisku Octave w wersji 3.2.4 lub wyższej. Natomiast programy w języku Python, każdy powinien móc uruchomić na swoim komputerze (ewentualnie, po uprzednim zainstalowaniu Pythona).

Kolejnym argumentem na korzyść Pythona jest to, że jest on pełnym językiem programowania, a nie środowiskiem dedykowanym do przeprowadzania obliczeń. To powoduje, że w razie potrzeby łatwiej jest wykorzystać Pythona do wykonywania operacji nie związanych wprost z obliczeniami. Dodatkowo duża liczba dedykowanych bibliotek, optymalizowanych pod kątem realizacji określonych zadań bardzo upraszcza implementację. Python może być używany jako język skryptowy służący np. automatyzacji powtarzających się zadań, a jednocześnie po zaimportowaniu odpowiednich bibliotek można go w sposób prosty wykorzystać do przeprowadzania naukowych obliczeń. Wiele aplikacji udostępnia swoje API właśnie w Pythonie. Jestem w stanie bez większych problemów wyobrazić sobie sytuację, gdzie w celu wykorzystania części swoich wcześniejszych programów w jednej z takich aplikacji, przekopiowuję bez żadnych zmian funkcje i fragmenty programów napisanych w Pythonie. Skrypty stworzone w Matlabie są w takiej sytuacji bezużyteczne.

Dla równowagi podkreślić należy kilka zalet środowiska Mathworks. Matlab jest jedną z najszerzej wykorzystywanych platform obliczeniowych na świecie. Od wielu lat wykorzystywany jest przez środowiska naukowe w różnych dziedzinach badań i do dziś stanowi standard w środowiskach uniwersyteckich. Przy wykorzystaniu Matlaba, wykonywane są obliczenia do większości publikacji naukowych, a przykładowe fragmenty kodu i algorytmy zapisywane są w języku Matlaba. Chociażby z tego powodu, aby pozostać w zgodzie z tym standardem, warto jest przynajmniej znać zapis Matlabowy.

Inną zaletą platformy Mathworks względem Pythona jest to, że dostarcza jednorodne, kompletne proste w instalacji środowisko zawierające w jednym miejscu wszystkie wymagane do pracy elementy. Bezpośrednio po instalacji, podczas której automatycznie instalowane są również zakupione toolboxy, użytkownik uruchamia jedno zwarte środowisko w którym dostępne są: okno poleceń, zintegrowany edytor, podgląd zmiennych w przestrzeniach pamięci, debugger, profiler, historia poleceń, przeglądarka plików, pomoc on-line, a nawet dostęp do internetowych baz skryptów udostępnianych przez społeczność użytkowników Matlaba. Pracę ułatwiają między innymi kreatory importu i eksportu danych z popularnych formatów plików, obsługa schowka, czy zintegrowane narzędzia do edycji wykresów. Moim zdaniem, to jest bardzo duży atut Matlaba, że zaraz po krótkiej instalacji stanowi kompletne środowisko zawierające zintegrowane liczne narzędzia ułatwiające pracę.

Innym bardzo dużym atutem produktu Mathworks jest Simulink – środowisko do przeprowadzania symulacji i projektowania, zintegrowane z Matlabem. Do Simulinka również można dokupić dedykowane toolboxy. Simulink w połączeniu z Matlabem stanowi potężną platformę mogącą służyć analizie zachowań systemów dynamicznych, wizualizacji symulacji, modelowaniu danych i wielu innym zastosowaniom. Obecnie nie ma na rynku konkurencyjnego do Simulinka oprogramowania o podobnych możliwościach.

W internecie znajduje się wiele stron porównujących Matlaba i Pythona przy różnego rodzaju zastosowaniach. Wymienione powyżej argumenty za każdym z tych dwóch środowisk to moje subiektywne zdanie. Wypunktowałem różnice, które są istotne według mnie i w konkretnych zastosowaniach, z którymi mam do czynienia – obliczeniami w zakresie analizy sygnałów. Inne osoby mogą przywiązywać wagę do innych cech obu języków w zależności od swoich przyzwyczajeń lub oczekiwań. Żeby móc ocenić praktyczne aspekty pracy z tymi językami, chciałbym wykonać kilka obliczeń w obu środowiskach porównując łatwość implementacji, czas wykonania itp. Ponieważ z jednej strony nie mam dużego doświadczenia z programowaniem w Pythonie, a z drugiej strony chciałbym zrobić coś ciekawszego niż wypisanie na ekranie liczb w pętli, to w następnych artykułach przedstawię zastosowanie obu języków do kilku prostych przypadków analizy modelowanych sygnałów, a także dźwięku i obrazu.

Użytkownicy systemów Windows, mogą pobrać skompilowane wersje wielu bibliotek Pythona do obliczeń naukowych ze strony: Unofficial Windows Binaries for Python Extension Packages, utrzymywanej przez Christopha Gohlke. Użytkownikom systemów linuksowych najłatwiej będzie użyć bibliotek z oficjalnych repozytoriów lub skompilować najnowsze wersje ze źródeł.

Na zakończenie odnośniki do dwóch środowisk obliczeniowych o otwartym kodzie źródłowym: Scilab i SAGE.