TPDS – Laborator 8

Determinarea unor trăsături ale semnalelor

A. Determinarea Peak-urilor

1. Problema radarului în automotive

Autoturismele trebuie să detecteze cu exactitate distanța, viteza și direcția oricărui obiect care ar
putea să apară in proximitatea sa (alt automobil, pieton, mingea unui copil, o pasare sau un obiect
agatat). Radarul cu unde continui (Continuous-wave radar) este cel mai bun mod de a aduna aceste
date, iar sistemele auto trebuie să interpreteze corect datele pentru a lua deciziile potrivite. Pe lângă
viteza tintei, direcția și unghiul de sosire a undei refectate trebuie determinat dacă obiectul detectat
este real sau "fals pozitiv" din zgomotul de mediu.

Cel mai utilizat algoritm este CFAR (Constant False Alarm Rate - En sau Rata constantă de alarmă
falsă - Ro) care are rolul unui "filtru" pentru a determina dacă un obiect detectat este probabil să fie
un obiect real sau face parte din "zgomotul" de fundal. Mai exact, acest algoritm determină pragul
puterii zgomotului peste care se poate considera că orice întoarcere ar putea proveni probabil dintr-o
țintă. Dacă acest prag este prea mic, atunci sunt detectate mai multe ținte în detrimentul numărului
crescut de alarme false. În schimb, dacă pragul este prea mare, atunci sunt detectate mai puține ținte,
dar numărul de alarme false este de asemenea scăzut. În majoritatea cazurilor, acest prag este
determinat algoritmic pentru a calcula probabilitatea unei alarme false - sau echivalent, a ratei de
alarmă falsă sau a timpului dintre alarmele false.

Algoritmul este descries foarte bine în documentația Matlab

(https://www.mathworks.com/help/phased/examples/constant-false-alarm-rate-cfar-detection.html).
Ideea constă în a împărți semnalul sau spectrul acestuia în celule (ferestre) dintre care unele sunt de
training iar la un anumit moment una este testată (CUT - cell under test) prin comparare cu estimările
făcute anterior.

Celule de protecție (Guard Cells) sunt utilizate pentru a evita alterarea acestei estimări chiar de către
puterea proprie a celulei de testat. Celulele adiacente CUT sunt in mod normal ignorate.

Dacă xj este valoarea calculată pentru celula j de testat, se declară că celula are un peak dacă valoarea
xj este mai mare decât valorile adiacente și xj>T, unde T este pragul admis. Formulele utilizate sunt:
TPDS – Laborator 8

unde α este factorul de prag, Pn semnifică puterea zgomotului celulelor de training, N este numărul
de celule de training iar Pfa semnifică rata de alarmă falsă. Se observă că o valoare scazută a ratei de
alarmă falsă determină un nivel ridicat al pragului, iar Pragul este o funcție atât a probabilității de
detectare, cât și a probabilității de alarmă falsă.

O posibilă implementare în Python pentru o funcție de detecție a Peak-urilor associate cu recepția

unei unde reflectate este următoarea:

def detect_peaks(x, num_train, num_guard, rate_fa):

"""
Detect peaks with CFAR algorithm.
num_train: Number of training cells.
num_guard: Number of guard cells.
rate_fa: False alarm rate.
"""
num_cells = x.size
num_train_half = round(num_train / 2)
num_guard_half = round(num_guard / 2)
num_side = num_train_half + num_guard_half

alpha = num_train*(rate_fa**(-1/num_train) - 1) # threshold factor

peak_idx = []
for i in range(num_side, num_cells - num_side):

if i != i-num_side+np.argmax(x[i-num_side:i+num_side+1]):
continue

sum1 = np.sum(x[i-num_side:i+num_side+1])
sum2 = np.sum(x[i-num_guard_half:i+num_guard_half+1])
p_noise = (sum1 - sum2) / num_train
threshold = alpha * p_noise
print(" threshold=", threshold)

if x[i] > threshold:

print(" i=", i)
peak_idx.append(i)
peak_idx = np.array(peak_idx, dtype=int)
return peak_idx

Testați această funcție pentru un semnal simulat

y = np.sin(2*np.pi*5*np.linspace(0, 1, 200)) + np.random.randn(200)/5
TPDS – Laborator 8
x = np.arange(y.size)

Afisați vectorul peak-urilor si reprezentați graphic semnalul si rezultatul detecției.

Observați efectul modificării parametrilor funcției date.

2. Determinarea vârfurilor și a ”văilor” în seturile de date

Dacă y este semnalul suspus analizei, atunci valorile minime și maxime pot fi găsite cu o secvență
de tipul următor
a = np.diff(np.sign(np.diff(y))).nonzero()[0] + 1 # local min & max

b = (np.diff(np.sign(np.diff(y))) > 0).nonzero()[0] + 1 # local min

c = (np.diff(np.sign(np.diff(y))) < 0).nonzero()[0] + 1 # local max

Pentru semnalul de la punctul anterior, reprezentați rezultatele obținute.

O alta posibilitate este de a utiliza find_peaks din scipy:
peaks,_ = sp.signal.find_peaks(y, height=0)
Reprezenți graphic. Testați rezultatul obținut pentru diferite argumente ale find_peaks.

B. Zero-Crrosing
1. Cea mai simplă abordare în Python este cea care utilizează funții din numpy:
a3 = [1, 2, 1, 1, 0, -3, -4, 7, 8, 9, 10, 0, -2, 0, 0, 1, 0, -
3, 0, 5, 6, 7, -10]
s3= np.sign(a3)
s3[s3==0] = -1 # replace zeros with -1
zero_crossings3 = np.where(np.diff(s3))[0]
print (s3)
print (zero_crossings3)
print (len(zero_crossings3))

2. Dar, dacă se dorește analiza (extragerea de trăsături și clasificarea) semnalelor audio, este
mult mai comod să se uilizeze biblioteca librosa.

Librosa se instalează funcție de varianta de Python utilizată.

Pentru Anaconda
conda install -c conda-forge librosa

O posibilă implementare:

import librosa as lb
import librosa.display

x, sr = lb.load(…../nice-work.wav') # sr – sampling rate pt fis wav

print (sr)
print(x.shape)
TPDS – Laborator 8
plt.figure(figsize=(14, 5))
plt.title('Wave from wav')
librosa.display.waveplot(x, sr=sr)
n0 = 6500 #se considera doar o parte din eșantioane
n1 = 7500 #se considera doar o parte din eșantioane
plt.figure(figsize=(14, 5))
plt.title('A frame of wave')
plt.plot(x[n0:n1])

zero_crossings = librosa.zero_crossings(x[n0:n1], pad=False)

zero_crossings.shape
print('Sum of zero_crossing',sum(zero_crossings))

zcrs = librosa.feature.zero_crossing_rate(x)
print(zcrs.shape)

plt.figure(figsize=(14, 5))
plt.plot(zcrs[0])

Obs.: din motive legate de codecurile instalate, vom lucre cu fisiere wav.

Comparati rezultatele obținute pentru fișierele de pe Moodle.