def get_shannon_index(self, total_bins=8):
frequency_interval = int(
np.ceil(1000.0 / (self.fs / float(self.n_fft))))
bin_probs = []
i = 0
psd = (1.0 / self.win_len) * (self.stft**2)
psd = AudioProcessing.rescale(psd, (0, 1))
psd_sum = np.sum(psd)
while i < total_bins * frequency_interval:
if i + frequency_interval > total_bins * frequency_interval:
bin = psd[i:, :]
else:
bin = psd[i:i + frequency_interval, :]
bin_probs.append(np.sum(bin))
i = i + frequency_interval
bin_probs = np.array(bin_probs)
bin_probs = bin_probs / psd_sum
shannon_index = AudioProcessing.get_entropy(bin_probs) / np.log2(
len(bin_probs))
return shannon_index
def get_spectral_average_variance_entropy(self):
segments_stft = None
N = 2**10
stft = np.copy(self.stft)
# stft = AudioProcessing.rescale(self.stft,(0,N))
# stft = stft.astype(np.uint16)
for segment in self.segments:
start = int(float(segment[0]) / self.n_fft)
stop = int(float(segment[1]) / self.n_fft)
if segments_stft is None:
segments_stft = stft[:, start:stop]
else:
segments_stft = np.concatenate(
(segments_stft, stft[:, start:stop]), axis=1)
average_spectra = np.mean(segments_stft, axis=1)
var_spectra = np.var(segments_stft, axis=1)
N = 2**8
average_spectra = AudioProcessing.rescale(average_spectra, (0, N))
average_spectra = average_spectra.astype(np.uint8)
var_spectra = AudioProcessing.rescale(var_spectra, (0, N))
var_spectra = var_spectra.astype(np.uint8)
avg_pdf, bins = AudioProcessing.get_histogram(average_spectra,
bins=np.arange(0, 255))
var_pdf, bins = AudioProcessing.get_histogram(var_spectra,
bins=np.arange(0, 255))
avg_pdf = avg_pdf[np.nonzero(avg_pdf)]
var_pdf = var_pdf[np.nonzero(var_pdf)]
average_spectrum_entropy = AudioProcessing.get_entropy(
avg_pdf) / np.log2(N)
variance_spectrum_entropy = AudioProcessing.get_entropy(
var_pdf) / np.log2(N)
return average_spectrum_entropy, variance_spectrum_entropy
def _get_spectral_entropy(self):
stft = np.copy(self.stft)
N = 2**10
stft = AudioProcessing.rescale(stft, (0, N))
stft = stft.astype(np.uint16)
item_frequency = itemfreq(stft)
total_samples = stft.size
pmf = []
for i in range(item_frequency.shape[0]):
pmf.append(item_frequency[i][1])
pmf = np.array(pmf)
pmf = pmf / float(total_samples)
self.spectral_entropy = AudioProcessing.get_entropy(pmf) / np.log2(N)
def _get_temporal_entropy(self):
envelope = self.envelope[np.nonzero(self.envelope)]
envelope_energy = envelope**2
N = 2**10 # (i.e 1024 values of envelope energy possible)
envelope_energy = AudioProcessing.rescale(envelope_energy, (0, N))
envelope_energy = envelope_energy.astype(np.uint16)
item_frequency = itemfreq(envelope_energy)
total_samples = envelope_energy.size
pmf = []
for i in range(item_frequency.shape[0]):
pmf.append(item_frequency[i][1])
pmf = np.array(pmf)
pmf = pmf / float(total_samples)
self.temporal_entropy = AudioProcessing.get_entropy(pmf) / np.log2(N)
def get_number_of_peaks(self):
stft = np.copy(self.stft)
stft = AudioProcessing.rescale(stft, (0, 1))
no_peaks = 0
min_distance = np.ceil(
int(np.ceil(200.0 / (self.fs / float(self.n_fft)))) / 3.0)
for i in range(stft.shape[1]):
col = stft[:, i]
import pdb
pdb.set_trace()
peaks = peakutils.indexes(col, thres=0.3, min_dist=min_distance)
for peak in peaks:
if peak != 0:
if col[peak] - col[peak - 1] > 0.01:
no_peaks = no_peaks + 1
return no_peaks