insect-audio-features 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- insect_audio_features/__init__.py +10 -0
- insect_audio_features-0.1.0.dist-info/METADATA +75 -0
- insect_audio_features-0.1.0.dist-info/RECORD +9 -0
- insect_audio_features-0.1.0.dist-info/WHEEL +5 -0
- insect_audio_features-0.1.0.dist-info/top_level.txt +3 -0
- main.py +68 -0
- src/extractors/librosa.py +124 -0
- src/extractors/padrao.py +162 -0
- src/utils/dataset_processor.py +176 -0
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
"""Acesso às funções originais do projeto de extração."""
|
|
2
|
+
from main import extract_features
|
|
3
|
+
from src.extractors.librosa import extract_features_librosa, get_feature_columns_librosa
|
|
4
|
+
from src.extractors.padrao import extract_features_padrao, get_feature_columns
|
|
5
|
+
|
|
6
|
+
__all__ = [
|
|
7
|
+
'extract_features',
|
|
8
|
+
'extract_features_librosa', 'get_feature_columns_librosa',
|
|
9
|
+
'extract_features_padrao', 'get_feature_columns',
|
|
10
|
+
]
|
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
Metadata-Version: 2.4
|
|
2
|
+
Name: insect-audio-features
|
|
3
|
+
Version: 0.1.0
|
|
4
|
+
Summary: Python feature extraction for insect optoacoustic signals
|
|
5
|
+
Author: Gabriel Cavalcante Velasquez
|
|
6
|
+
Project-URL: Repository, https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark
|
|
7
|
+
Project-URL: Issues, https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark/issues
|
|
8
|
+
Keywords: insects,optoacoustic,audio,feature-extraction,librosa
|
|
9
|
+
Requires-Python: >=3.10
|
|
10
|
+
Description-Content-Type: text/markdown
|
|
11
|
+
Requires-Dist: numpy<3,>=1.24
|
|
12
|
+
Requires-Dist: pandas<4,>=2
|
|
13
|
+
Requires-Dist: scipy<2,>=1.10
|
|
14
|
+
Requires-Dist: librosa<2,>=0.11
|
|
15
|
+
Requires-Dist: audioflux<0.2,>=0.1.9
|
|
16
|
+
Requires-Dist: audio-metadata<0.12,>=0.11.1
|
|
17
|
+
|
|
18
|
+
# Insect Audio Features
|
|
19
|
+
|
|
20
|
+
Biblioteca Python para extração de atributos de sinais optoacústicos de insetos. Oferece dois métodos: `librosa` e `padrao` (referência do laboratório).
|
|
21
|
+
|
|
22
|
+
## Instalação
|
|
23
|
+
|
|
24
|
+
Após publicação no PyPI:
|
|
25
|
+
|
|
26
|
+
```bash
|
|
27
|
+
pip install insect-audio-features
|
|
28
|
+
```
|
|
29
|
+
|
|
30
|
+
Para desenvolvimento, na raiz do repositório:
|
|
31
|
+
|
|
32
|
+
```bash
|
|
33
|
+
pip install -e .
|
|
34
|
+
```
|
|
35
|
+
|
|
36
|
+
## Uso
|
|
37
|
+
|
|
38
|
+
```python
|
|
39
|
+
from insect_audio_features import extract_features, get_feature_columns_librosa
|
|
40
|
+
|
|
41
|
+
print(get_feature_columns_librosa())
|
|
42
|
+
|
|
43
|
+
df = extract_features(
|
|
44
|
+
path_dataset='Aedes aegypti (female).zip',
|
|
45
|
+
path_output='resultados/librosa.csv',
|
|
46
|
+
biblioteca='librosa',
|
|
47
|
+
)
|
|
48
|
+
print(df.head())
|
|
49
|
+
```
|
|
50
|
+
|
|
51
|
+
A entrada pode ser um ZIP, uma pasta contendo ZIPs ou uma lista de caminhos. Cada ZIP contém arquivos WAV, inclusive em subpastas. O resultado é salvo em CSV e também retornado como `pandas.DataFrame`.
|
|
52
|
+
|
|
53
|
+
As três primeiras colunas são `zip_name`, `file_path` e `label`. O rótulo é inferido pelo pipeline a partir do nome do ZIP ou, conforme sua estrutura, da pasta do áudio. Confira a rotulagem antes de utilizar os resultados.
|
|
54
|
+
|
|
55
|
+
## Métodos
|
|
56
|
+
|
|
57
|
+
- **Librosa:** RMS, cruzamento por zero, centroide, largura de banda, planicidade, roll-off, sete bandas de contraste e 13 MFCCs (26 atributos).
|
|
58
|
+
- **Padrão:** temperatura quando disponível, frequência de batimento das asas, complexidade, duração, inarmonicidade, picos e energias harmônicas. Consulte `get_feature_columns()` para a lista exata.
|
|
59
|
+
|
|
60
|
+
Também é possível processar um WAV individual:
|
|
61
|
+
|
|
62
|
+
```python
|
|
63
|
+
from insect_audio_features import extract_features_librosa
|
|
64
|
+
features = extract_features_librosa('audio.wav')
|
|
65
|
+
```
|
|
66
|
+
|
|
67
|
+
Os algoritmos mantêm os parâmetros do projeto de pesquisa, incluindo taxa de 44,1 kHz e janela de 1.024 amostras. Não há remoção automática de silêncio. A extração individual pode falhar em áudios inválidos ou incompatíveis; no processamento em lote, essas falhas são informadas no terminal e as amostras são omitidas. Um CSV existente no destino é sobrescrito.
|
|
68
|
+
|
|
69
|
+
## Escopo
|
|
70
|
+
|
|
71
|
+
O pacote contém apenas extração e processamento de arquivos. Não inclui base de áudios, resultados experimentais, classificadores ou interface web. Dependências numéricas e de áudio são instaladas separadamente pelo pip; sua compatibilidade depende da plataforma e da versão do Python. A validação inicial foi realizada em Linux com Python 3.13.
|
|
72
|
+
|
|
73
|
+
## Organização preservada
|
|
74
|
+
|
|
75
|
+
Os arquivos originais continuam em `main.py`, `src/extractors` e `src/utils`, com os mesmos imports e funções. `insect_audio_features/__init__.py` apenas disponibiliza essas funções para importação pelo nome do pacote. Não há outra implementação de extração. O pacote mantém os nomes de módulos originais `main` e `src`; instale-o em um ambiente virtual dedicado para evitar conflitos com outros projetos que utilizem esses mesmos nomes.
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
main.py,sha256=Pcud5GPOJ5JV1DFt4EekyG_o2dh0N-Om7v3YoHzl5Gc,2190
|
|
2
|
+
insect_audio_features/__init__.py,sha256=_7nOzHt-TVD5l4wxzdNrBIezUUOkrM8TSXR2OEDMKbM,421
|
|
3
|
+
src/extractors/librosa.py,sha256=sLq-qDm_MD2sdhWVxfGaups4YUx041Q4k_4qi6Pe6EA,3968
|
|
4
|
+
src/extractors/padrao.py,sha256=8pPw1COJDp1-3HNradL8iuZNXwNe6bhKaLnhu0-su2w,5890
|
|
5
|
+
src/utils/dataset_processor.py,sha256=_Yeta-p18GlAqxLDDK2a8RLL_4Ejsn_VCbKFxMawgnw,6603
|
|
6
|
+
insect_audio_features-0.1.0.dist-info/METADATA,sha256=Kv7pSAzASVpgFpmdN9G-F7pc0BWuVQyXUAaz88ohPmU,3565
|
|
7
|
+
insect_audio_features-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
|
|
8
|
+
insect_audio_features-0.1.0.dist-info/top_level.txt,sha256=C08I_-eZJ5sIqTPnC0wl3xozoPqMDEPrWrIN8_C8zE0,31
|
|
9
|
+
insect_audio_features-0.1.0.dist-info/RECORD,,
|
main.py
ADDED
|
@@ -0,0 +1,68 @@
|
|
|
1
|
+
from pathlib import Path
|
|
2
|
+
import pandas as pd
|
|
3
|
+
|
|
4
|
+
from src.extractors.padrao import extract_features_padrao, get_feature_columns
|
|
5
|
+
from src.extractors.librosa import extract_features_librosa, get_feature_columns_librosa
|
|
6
|
+
from src.utils.dataset_processor import process_dataset
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
def extract_features(
|
|
10
|
+
path_dataset: str | Path | list[str | Path],
|
|
11
|
+
path_output: str | Path,
|
|
12
|
+
biblioteca: str = "",
|
|
13
|
+
):
|
|
14
|
+
"""Extrai atributos acústicos do dataset usando a biblioteca de extração especificada.
|
|
15
|
+
|
|
16
|
+
Parâmetros:
|
|
17
|
+
path_dataset: Caminho da pasta ou lista de arquivos ZIP contendo os áudios.
|
|
18
|
+
path_output: Caminho do arquivo CSV de saída.
|
|
19
|
+
biblioteca: Nome do método/biblioteca de extração ('padrao', 'librosa', 'audioflux').
|
|
20
|
+
"""
|
|
21
|
+
biblioteca_norm = biblioteca.strip().lower()
|
|
22
|
+
|
|
23
|
+
if biblioteca_norm == "padrao":
|
|
24
|
+
return process_dataset(
|
|
25
|
+
data_dirs=path_dataset,
|
|
26
|
+
output_csv=path_output,
|
|
27
|
+
extract_one_func=extract_features_padrao,
|
|
28
|
+
feature_columns=get_feature_columns(),
|
|
29
|
+
)
|
|
30
|
+
elif biblioteca_norm == "librosa":
|
|
31
|
+
return process_dataset(
|
|
32
|
+
data_dirs=path_dataset,
|
|
33
|
+
output_csv=path_output,
|
|
34
|
+
extract_one_func=extract_features_librosa,
|
|
35
|
+
feature_columns=get_feature_columns_librosa(),
|
|
36
|
+
)
|
|
37
|
+
else:
|
|
38
|
+
raise ValueError(
|
|
39
|
+
f"Biblioteca '{biblioteca}' não reconhecida! Opções disponíveis: ['padrao', 'librosa']"
|
|
40
|
+
)
|
|
41
|
+
|
|
42
|
+
|
|
43
|
+
def main():
|
|
44
|
+
extratores = {
|
|
45
|
+
"librosa": {
|
|
46
|
+
"path_dataset": "data/raw/females",
|
|
47
|
+
"path_output": "features/librosa/librosa.csv",
|
|
48
|
+
},
|
|
49
|
+
"padrao": {
|
|
50
|
+
"path_dataset": "data/raw/females",
|
|
51
|
+
"path_output": "features/padrao/padrao.csv",
|
|
52
|
+
},
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
extratores_rodar = ["librosa", "padrao"]
|
|
56
|
+
|
|
57
|
+
for biblioteca in extratores_rodar:
|
|
58
|
+
dados_extracao = extratores[biblioteca]
|
|
59
|
+
extract_features(
|
|
60
|
+
path_dataset=dados_extracao["path_dataset"],
|
|
61
|
+
path_output=dados_extracao["path_output"],
|
|
62
|
+
biblioteca=biblioteca,
|
|
63
|
+
)
|
|
64
|
+
print("\nExtração concluída!")
|
|
65
|
+
|
|
66
|
+
|
|
67
|
+
if __name__ == "__main__":
|
|
68
|
+
main()
|
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
"""Extrator de atributos acústicos utilizando a biblioteca Librosa.
|
|
2
|
+
|
|
3
|
+
Atributos implementados:
|
|
4
|
+
- Temporais:
|
|
5
|
+
- rms: Root-Mean-Square energy por frame
|
|
6
|
+
- zero_crossing_rate: Taxa de cruzamento por zero
|
|
7
|
+
- Espectrais:
|
|
8
|
+
- spectral_centroid: Centróide espectral
|
|
9
|
+
- spectral_bandwidth: Largura de banda espectral
|
|
10
|
+
- spectral_contrast: Contraste espectral (7 bandas)
|
|
11
|
+
- spectral_flatness: Planicidade espectral
|
|
12
|
+
- spectral_rolloff: Frequência de decaimento espectral (roll-off)
|
|
13
|
+
- poly_features: Coeficientes polinomiais sobre o espectrograma (ordem 1)
|
|
14
|
+
- Tonal / Chroma:
|
|
15
|
+
- chroma_stft: Cromagrama via STFT (12 classes de pitch)
|
|
16
|
+
- chroma_cqt: Cromagrama via Constant-Q (12 classes de pitch)
|
|
17
|
+
- chroma_cens: Chroma Energy Normalized Statistics (CENS, 12 classes)
|
|
18
|
+
- chroma_vqt: Cromagrama via Variable-Q (12 classes de pitch)
|
|
19
|
+
- tonnetz: Características do centróide tonal (6 dimensões)
|
|
20
|
+
- Ceptrais e Banco de Filtros:
|
|
21
|
+
- mfcc: Coeficientes cepstrais na escala Mel (20 coeficientes)
|
|
22
|
+
- melspectrogram: Espectrograma em escala Mel (128 bandas)
|
|
23
|
+
"""
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
from pathlib import Path
|
|
30
|
+
import librosa
|
|
31
|
+
import numpy as np
|
|
32
|
+
|
|
33
|
+
SAMPLE_RATE = 44100
|
|
34
|
+
N_FFT = 1024
|
|
35
|
+
HOP_LENGTH = 512
|
|
36
|
+
N_MFCC = 13
|
|
37
|
+
N_CONTRAST_BANDS = 6
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
def get_feature_columns_librosa() -> list[str]:
|
|
41
|
+
"""Retorna os nomes das colunas de características geradas pelo Librosa."""
|
|
42
|
+
columns = [
|
|
43
|
+
"rms",
|
|
44
|
+
"zcr",
|
|
45
|
+
"spectral_centroid",
|
|
46
|
+
"spectral_bandwidth",
|
|
47
|
+
"spectral_flatness",
|
|
48
|
+
"spectral_rolloff",
|
|
49
|
+
]
|
|
50
|
+
for i in range(N_CONTRAST_BANDS + 1):
|
|
51
|
+
columns.append(f"spectral_contrast_band_{i + 1:02d}")
|
|
52
|
+
for i in range(N_MFCC):
|
|
53
|
+
columns.append(f"mfcc_{i + 1:02d}")
|
|
54
|
+
return columns
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def extract_features_librosa(audio_path: str | Path) -> dict[str, float]:
|
|
58
|
+
"""Extrai atributos acústicos brutos (temporais, espectrais e cepstrais) via Librosa.
|
|
59
|
+
|
|
60
|
+
Parâmetros:
|
|
61
|
+
audio_path: Caminho do arquivo de áudio WAV capturado pelo sensor óptico.
|
|
62
|
+
Retorna: Dicionário com os atributos nativos simplificados para a matriz de ML.
|
|
63
|
+
"""
|
|
64
|
+
y, sr = librosa.load(str(audio_path), sr=SAMPLE_RATE, mono=True)
|
|
65
|
+
|
|
66
|
+
features: dict[str, float] = {}
|
|
67
|
+
|
|
68
|
+
# Atributos Temporais Brutos
|
|
69
|
+
features["rms"] = float(
|
|
70
|
+
np.mean(librosa.feature.rms(y=y, frame_length=N_FFT, hop_length=HOP_LENGTH))
|
|
71
|
+
)
|
|
72
|
+
features["zcr"] = float(
|
|
73
|
+
np.mean(
|
|
74
|
+
librosa.feature.zero_crossing_rate(
|
|
75
|
+
y=y, frame_length=N_FFT, hop_length=HOP_LENGTH
|
|
76
|
+
)
|
|
77
|
+
)
|
|
78
|
+
)
|
|
79
|
+
|
|
80
|
+
# Atributos Espectrais Brutos
|
|
81
|
+
features["spectral_centroid"] = float(
|
|
82
|
+
np.mean(
|
|
83
|
+
librosa.feature.spectral_centroid(
|
|
84
|
+
y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH
|
|
85
|
+
)
|
|
86
|
+
)
|
|
87
|
+
)
|
|
88
|
+
features["spectral_bandwidth"] = float(
|
|
89
|
+
np.mean(
|
|
90
|
+
librosa.feature.spectral_bandwidth(
|
|
91
|
+
y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH
|
|
92
|
+
)
|
|
93
|
+
)
|
|
94
|
+
)
|
|
95
|
+
features["spectral_flatness"] = float(
|
|
96
|
+
np.mean(
|
|
97
|
+
librosa.feature.spectral_flatness(
|
|
98
|
+
y=y, n_fft=N_FFT, hop_length=HOP_LENGTH
|
|
99
|
+
)
|
|
100
|
+
)
|
|
101
|
+
)
|
|
102
|
+
features["spectral_rolloff"] = float(
|
|
103
|
+
np.mean(
|
|
104
|
+
librosa.feature.spectral_rolloff(
|
|
105
|
+
y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH
|
|
106
|
+
)
|
|
107
|
+
)
|
|
108
|
+
)
|
|
109
|
+
|
|
110
|
+
# Spectral Contrast (6 bandas de frequência -> 7 bandas no total)
|
|
111
|
+
contrast = librosa.feature.spectral_contrast(
|
|
112
|
+
y=y, sr=sr, n_fft=N_FFT, hop_length=HOP_LENGTH, n_bands=N_CONTRAST_BANDS
|
|
113
|
+
)
|
|
114
|
+
for i in range(contrast.shape[0]):
|
|
115
|
+
features[f"spectral_contrast_band_{i + 1:02d}"] = float(np.mean(contrast[i]))
|
|
116
|
+
|
|
117
|
+
# Atributos Cepstrais Brutos (13 MFCCs)
|
|
118
|
+
mfcc = librosa.feature.mfcc(
|
|
119
|
+
y=y, sr=sr, n_mfcc=N_MFCC, n_fft=N_FFT, hop_length=HOP_LENGTH
|
|
120
|
+
)
|
|
121
|
+
for i in range(N_MFCC):
|
|
122
|
+
features[f"mfcc_{i + 1:02d}"] = float(np.mean(mfcc[i]))
|
|
123
|
+
|
|
124
|
+
return features
|
src/extractors/padrao.py
ADDED
|
@@ -0,0 +1,162 @@
|
|
|
1
|
+
"""Extração de atributos acústicos a partir de arquivos de áudio WAV (Método Padrão do Laboratório)."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from pathlib import Path
|
|
6
|
+
|
|
7
|
+
import audio_metadata
|
|
8
|
+
import audioflux as af
|
|
9
|
+
import numpy as np
|
|
10
|
+
from scipy.fft import fft
|
|
11
|
+
|
|
12
|
+
# Constantes do método de extração acústica
|
|
13
|
+
SAMPLE_RATE = 44100
|
|
14
|
+
WINDOW_SIZE = 1024
|
|
15
|
+
PEAK_COUNT = 6
|
|
16
|
+
|
|
17
|
+
def hanning_window(size: int) -> np.ndarray:
|
|
18
|
+
"""Gera a janela de ponderação de Hanning."""
|
|
19
|
+
return 0.5 - 0.5 * np.cos(2 * np.pi * np.arange(size) / (size - 1))
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
def normalize_znorm(values: np.ndarray) -> np.ndarray:
|
|
23
|
+
"""Normalização estatística Z-score para blocos de complexidade."""
|
|
24
|
+
std = np.std(values)
|
|
25
|
+
return (values - np.mean(values)) / std if std > 0 else values
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
def get_temperature(file_path: Path | str) -> float | None:
|
|
29
|
+
"""Extrai a temperatura gravada nos metadados do áudio (tag T=...)."""
|
|
30
|
+
try:
|
|
31
|
+
metadata = audio_metadata.load(str(file_path))
|
|
32
|
+
comments = metadata.get("tags", {}).get("comment", [])
|
|
33
|
+
if comments:
|
|
34
|
+
for part in comments[0].split(","):
|
|
35
|
+
if part.startswith("T="):
|
|
36
|
+
return float(part.split("=", 1)[1])
|
|
37
|
+
except Exception:
|
|
38
|
+
pass
|
|
39
|
+
return None
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def wingbeat_frequency(
|
|
43
|
+
audio: np.ndarray,
|
|
44
|
+
sample_rate: int = SAMPLE_RATE,
|
|
45
|
+
f0_min: int = 200,
|
|
46
|
+
f0_max: int = 1200,
|
|
47
|
+
) -> float:
|
|
48
|
+
"""Estima a frequência fundamental (batimento de asas) via Cepstrum."""
|
|
49
|
+
cepstrum = fft(np.log(np.abs(fft(audio, sample_rate)) + 1e-12))
|
|
50
|
+
start = int(np.floor(sample_rate / f0_max))
|
|
51
|
+
end = min(int(np.ceil(sample_rate / f0_min)), len(cepstrum))
|
|
52
|
+
peak = np.argmax(np.abs(cepstrum[start:end]))
|
|
53
|
+
return float(sample_rate / (peak + start))
|
|
54
|
+
|
|
55
|
+
|
|
56
|
+
def get_feature_columns() -> list[str]:
|
|
57
|
+
"""Retorna os nomes das colunas de características geradas."""
|
|
58
|
+
harmonic_count = (
|
|
59
|
+
int((1200 / SAMPLE_RATE) * WINDOW_SIZE)
|
|
60
|
+
- int((100 / SAMPLE_RATE) * WINDOW_SIZE)
|
|
61
|
+
+ 1
|
|
62
|
+
)
|
|
63
|
+
return (
|
|
64
|
+
[
|
|
65
|
+
"temperature",
|
|
66
|
+
"wbf",
|
|
67
|
+
"complexity",
|
|
68
|
+
"complexity_znorm",
|
|
69
|
+
"time_length",
|
|
70
|
+
"inharmonicity",
|
|
71
|
+
]
|
|
72
|
+
+ [f"peaks_freq_{i}" for i in range(1, PEAK_COUNT + 1)]
|
|
73
|
+
+ [f"eh_{i}" for i in range(1, harmonic_count + 1)]
|
|
74
|
+
)
|
|
75
|
+
|
|
76
|
+
|
|
77
|
+
def extract_features_padrao(audio_path: Path | str) -> dict[str, float | None]:
|
|
78
|
+
"""Extrai os 38 atributos acústicos de um único arquivo de áudio WAV usando o método padrão."""
|
|
79
|
+
audio_path = Path(audio_path)
|
|
80
|
+
audio, actual_sample_rate = af.read(str(audio_path), samplate=SAMPLE_RATE)
|
|
81
|
+
audio = np.asarray(audio, dtype=np.float32).squeeze()
|
|
82
|
+
|
|
83
|
+
if audio.ndim != 1:
|
|
84
|
+
raise ValueError(f"Áudio não mono: formato {audio.shape}")
|
|
85
|
+
if audio.size < WINDOW_SIZE:
|
|
86
|
+
raise ValueError(f"Áudio possui menos de {WINDOW_SIZE} amostras ({audio.size})")
|
|
87
|
+
|
|
88
|
+
# 1. Espectro FFT com janelas sobrepostas
|
|
89
|
+
step = WINDOW_SIZE // 2
|
|
90
|
+
window_count = (audio.size // step) - (WINDOW_SIZE // step) + 1
|
|
91
|
+
spectrum = np.zeros(WINDOW_SIZE)
|
|
92
|
+
window = hanning_window(WINDOW_SIZE)
|
|
93
|
+
|
|
94
|
+
for index in range(window_count):
|
|
95
|
+
chunk = audio[index * step : index * step + WINDOW_SIZE]
|
|
96
|
+
if len(chunk) < WINDOW_SIZE:
|
|
97
|
+
chunk = np.pad(chunk, (0, WINDOW_SIZE - len(chunk)), "constant")
|
|
98
|
+
spectrum += np.abs(fft(chunk * window))
|
|
99
|
+
spectrum /= window_count
|
|
100
|
+
spectrum_log = 20 * np.log(spectrum + 1e-12)
|
|
101
|
+
|
|
102
|
+
# 2. Detecção dos picos de frequência
|
|
103
|
+
peak_bins = [
|
|
104
|
+
index
|
|
105
|
+
for index in range(1, WINDOW_SIZE // 2 - 1)
|
|
106
|
+
if spectrum_log[index] > spectrum_log[index - 1]
|
|
107
|
+
and spectrum_log[index] > spectrum_log[index + 1]
|
|
108
|
+
]
|
|
109
|
+
peak_bins = sorted(peak_bins, key=lambda idx: spectrum_log[idx], reverse=True)[
|
|
110
|
+
:PEAK_COUNT
|
|
111
|
+
]
|
|
112
|
+
|
|
113
|
+
peak_frequencies: list[float] = []
|
|
114
|
+
for peak in peak_bins:
|
|
115
|
+
left, center, right = spectrum[peak - 1 : peak + 2]
|
|
116
|
+
offset = (right - left) / (left + center + right + 1e-12)
|
|
117
|
+
peak_frequencies.append(float(SAMPLE_RATE / WINDOW_SIZE * (peak + offset)))
|
|
118
|
+
|
|
119
|
+
# 3. Energia dos harmônicos
|
|
120
|
+
first_bin = int(np.floor(100 / SAMPLE_RATE * WINDOW_SIZE))
|
|
121
|
+
last_bin = int(np.floor(1200 / SAMPLE_RATE * WINDOW_SIZE))
|
|
122
|
+
harmonic_energies: list[float] = []
|
|
123
|
+
for bin_index in range(first_bin, last_bin + 1):
|
|
124
|
+
harmonic_energies.append(
|
|
125
|
+
float(
|
|
126
|
+
sum(
|
|
127
|
+
spectrum[index]
|
|
128
|
+
for harmonic in range(4)
|
|
129
|
+
if (index := bin_index + harmonic * bin_index) < (WINDOW_SIZE // 2)
|
|
130
|
+
)
|
|
131
|
+
)
|
|
132
|
+
)
|
|
133
|
+
|
|
134
|
+
# 4. Complexidade do sinal
|
|
135
|
+
complexity = complexity_znorm = 0.0
|
|
136
|
+
complexity_chunks = 0
|
|
137
|
+
for index in range(0, audio.size - 512, 512):
|
|
138
|
+
chunk = audio[index : index + 512].astype(float)
|
|
139
|
+
complexity += float(np.sqrt(np.sum(np.diff(chunk) ** 2)))
|
|
140
|
+
complexity_znorm += float(np.sqrt(np.sum(np.diff(normalize_znorm(chunk)) ** 2)))
|
|
141
|
+
complexity_chunks += 1
|
|
142
|
+
if complexity_chunks:
|
|
143
|
+
complexity /= complexity_chunks
|
|
144
|
+
complexity_znorm /= complexity_chunks
|
|
145
|
+
|
|
146
|
+
# 5. Dicionário consolidado de features
|
|
147
|
+
features: dict[str, float | None] = {
|
|
148
|
+
"temperature": get_temperature(audio_path),
|
|
149
|
+
"wbf": wingbeat_frequency(audio, SAMPLE_RATE),
|
|
150
|
+
"complexity": float(complexity),
|
|
151
|
+
"complexity_znorm": float(complexity_znorm),
|
|
152
|
+
"time_length": float(len(audio) / actual_sample_rate),
|
|
153
|
+
"inharmonicity": float(np.std(peak_frequencies)) if peak_frequencies else 0.0,
|
|
154
|
+
}
|
|
155
|
+
for index in range(PEAK_COUNT):
|
|
156
|
+
features[f"peaks_freq_{index + 1}"] = (
|
|
157
|
+
float(peak_frequencies[index]) if index < len(peak_frequencies) else None
|
|
158
|
+
)
|
|
159
|
+
for index, energy in enumerate(harmonic_energies, start=1):
|
|
160
|
+
features[f"eh_{index}"] = float(energy)
|
|
161
|
+
|
|
162
|
+
return features
|
|
@@ -0,0 +1,176 @@
|
|
|
1
|
+
"""Funções auxiliares para busca, inspeção e processamento de arquivos do dataset."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import csv
|
|
6
|
+
import re
|
|
7
|
+
import sys
|
|
8
|
+
import tempfile
|
|
9
|
+
import zipfile
|
|
10
|
+
from pathlib import Path, PurePosixPath
|
|
11
|
+
from typing import Callable
|
|
12
|
+
|
|
13
|
+
import pandas as pd
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
def find_zip_archives(data_dirs: str | Path | list[str | Path]) -> list[Path]:
|
|
17
|
+
"""Busca e retorna todos os arquivos .zip a partir de uma pasta, arquivo ou lista de caminhos."""
|
|
18
|
+
if isinstance(data_dirs, (str, Path)):
|
|
19
|
+
dirs_list = [data_dirs]
|
|
20
|
+
else:
|
|
21
|
+
dirs_list = list(data_dirs)
|
|
22
|
+
|
|
23
|
+
archives: list[Path] = []
|
|
24
|
+
for item in dirs_list:
|
|
25
|
+
if not item:
|
|
26
|
+
continue
|
|
27
|
+
path_item = Path(item)
|
|
28
|
+
if path_item.is_dir():
|
|
29
|
+
archives.extend(sorted(path_item.glob("*.zip")))
|
|
30
|
+
elif path_item.is_file() and path_item.suffix.lower() == ".zip":
|
|
31
|
+
archives.append(path_item)
|
|
32
|
+
|
|
33
|
+
if not archives:
|
|
34
|
+
raise FileNotFoundError(f"Nenhum arquivo .zip encontrado nos caminhos: {dirs_list}")
|
|
35
|
+
|
|
36
|
+
return archives
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
def get_labels(archive_path: Path | str) -> tuple[str, str, str]:
|
|
40
|
+
"""Extrai (label_completo, especie, sexo) a partir do nome do arquivo ZIP.
|
|
41
|
+
|
|
42
|
+
Exemplo: 'Aedes aegypti (female)-...zip' -> ('Aedes aegypti (female)', 'Aedes aegypti', 'female')
|
|
43
|
+
"""
|
|
44
|
+
archive_path = Path(archive_path)
|
|
45
|
+
label_pattern = re.compile(
|
|
46
|
+
r"^(?P<species>.+?)\s+\((?P<sex>female|male)\)", re.IGNORECASE
|
|
47
|
+
)
|
|
48
|
+
match = label_pattern.match(archive_path.stem)
|
|
49
|
+
if not match:
|
|
50
|
+
stem = archive_path.stem
|
|
51
|
+
label = stem.split("-")[0].strip() if "-" in stem else stem
|
|
52
|
+
return label, label, ""
|
|
53
|
+
species = match.group("species").strip()
|
|
54
|
+
sex = match.group("sex").lower()
|
|
55
|
+
return f"{species} ({sex})", species, sex
|
|
56
|
+
|
|
57
|
+
|
|
58
|
+
def get_wav_members(archive: zipfile.ZipFile) -> list[zipfile.ZipInfo]:
|
|
59
|
+
"""Filtra apenas arquivos .wav válidos dentro de um arquivo ZIP (ignora __MACOSX)."""
|
|
60
|
+
members: list[zipfile.ZipInfo] = []
|
|
61
|
+
for info in archive.infolist():
|
|
62
|
+
path = PurePosixPath(info.filename)
|
|
63
|
+
if path.is_absolute() or ".." in path.parts:
|
|
64
|
+
raise ValueError(f"Caminho inseguro dentro do ZIP: {info.filename!r}")
|
|
65
|
+
if (
|
|
66
|
+
not info.is_dir()
|
|
67
|
+
and path.suffix.lower() == ".wav"
|
|
68
|
+
and not info.filename.startswith("__MACOSX")
|
|
69
|
+
):
|
|
70
|
+
members.append(info)
|
|
71
|
+
return members
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
def process_archive(
|
|
75
|
+
archive_path: Path | str,
|
|
76
|
+
extract_one_func: Callable[[Path | str], dict],
|
|
77
|
+
writer: csv.DictWriter | None = None,
|
|
78
|
+
) -> pd.DataFrame | tuple[int, int]:
|
|
79
|
+
"""Processa um único arquivo ZIP aplicando a função extract_one em cada áudio WAV.
|
|
80
|
+
|
|
81
|
+
Se `writer` for fornecido, grava diretamente no CSV e retorna (processados, falhas).
|
|
82
|
+
Se `writer` for None, retorna um pd.DataFrame com os resultados daquele ZIP.
|
|
83
|
+
"""
|
|
84
|
+
archive_path = Path(archive_path)
|
|
85
|
+
class_name, _, _ = get_labels(archive_path)
|
|
86
|
+
print(f"-> Processando: {archive_path.name} [Classe: {class_name}]")
|
|
87
|
+
|
|
88
|
+
processed = failures = 0
|
|
89
|
+
records: list[dict] = []
|
|
90
|
+
|
|
91
|
+
with zipfile.ZipFile(archive_path) as archive, tempfile.TemporaryDirectory(
|
|
92
|
+
prefix="benchmark_"
|
|
93
|
+
) as temp_dir:
|
|
94
|
+
for member in get_wav_members(archive):
|
|
95
|
+
extracted_path = Path(temp_dir) / member.filename
|
|
96
|
+
try:
|
|
97
|
+
archive.extract(member, temp_dir)
|
|
98
|
+
features = extract_one_func(extracted_path)
|
|
99
|
+
row = {
|
|
100
|
+
"zip_name": archive_path.name,
|
|
101
|
+
"file_path": member.filename,
|
|
102
|
+
"label": class_name,
|
|
103
|
+
**features,
|
|
104
|
+
}
|
|
105
|
+
if writer is not None:
|
|
106
|
+
writer.writerow(row)
|
|
107
|
+
else:
|
|
108
|
+
records.append(row)
|
|
109
|
+
processed += 1
|
|
110
|
+
except Exception as exc:
|
|
111
|
+
failures += 1
|
|
112
|
+
print(
|
|
113
|
+
f"Aviso: falha em {archive_path.name}/{member.filename}: {exc}",
|
|
114
|
+
file=sys.stderr,
|
|
115
|
+
)
|
|
116
|
+
finally:
|
|
117
|
+
if extracted_path.exists():
|
|
118
|
+
try:
|
|
119
|
+
extracted_path.unlink()
|
|
120
|
+
except OSError:
|
|
121
|
+
pass
|
|
122
|
+
|
|
123
|
+
if writer is None:
|
|
124
|
+
return pd.DataFrame(records)
|
|
125
|
+
return processed, failures
|
|
126
|
+
|
|
127
|
+
|
|
128
|
+
def process_dataset(
|
|
129
|
+
data_dirs: str | Path | list[str | Path],
|
|
130
|
+
output_csv: str | Path,
|
|
131
|
+
extract_one_func: Callable[[Path | str], dict],
|
|
132
|
+
feature_columns: list[str] | None = None,
|
|
133
|
+
) -> pd.DataFrame:
|
|
134
|
+
"""Processa todos os arquivos ZIP de um dataset, aplicando extract_one_func em cada áudio e salvando em CSV.
|
|
135
|
+
|
|
136
|
+
Parâmetros:
|
|
137
|
+
data_dirs: Pasta, arquivo ou lista contendo os arquivos .zip do dataset.
|
|
138
|
+
output_csv: Caminho do arquivo CSV de saída para salvar os atributos extraídos.
|
|
139
|
+
extract_one_func: Função de extração que recebe o caminho de um único áudio e retorna um dicionário.
|
|
140
|
+
feature_columns: Lista com os nomes dos atributos (opcional; se None, deduz a partir da primeira extração).
|
|
141
|
+
"""
|
|
142
|
+
archives = find_zip_archives(data_dirs)
|
|
143
|
+
output_path = Path(output_csv)
|
|
144
|
+
output_path.parent.mkdir(parents=True, exist_ok=True)
|
|
145
|
+
|
|
146
|
+
if feature_columns is None:
|
|
147
|
+
# Descobre as colunas de atributos a partir do primeiro áudio disponível
|
|
148
|
+
first_archive = archives[0]
|
|
149
|
+
with zipfile.ZipFile(first_archive) as arc, tempfile.TemporaryDirectory(
|
|
150
|
+
prefix="benchmark_sample_"
|
|
151
|
+
) as tmp:
|
|
152
|
+
wavs = get_wav_members(arc)
|
|
153
|
+
if not wavs:
|
|
154
|
+
raise ValueError(f"Nenhum arquivo WAV encontrado no arquivo {first_archive}")
|
|
155
|
+
sample_path = Path(tmp) / wavs[0].filename
|
|
156
|
+
arc.extract(wavs[0], tmp)
|
|
157
|
+
sample_features = extract_one_func(sample_path)
|
|
158
|
+
feature_columns = list(sample_features.keys())
|
|
159
|
+
|
|
160
|
+
fieldnames = ["zip_name", "file_path", "label", *feature_columns]
|
|
161
|
+
|
|
162
|
+
total_processed = total_failures = 0
|
|
163
|
+
with output_path.open("w", newline="", encoding="utf-8") as output_file:
|
|
164
|
+
writer = csv.DictWriter(output_file, fieldnames=fieldnames)
|
|
165
|
+
writer.writeheader()
|
|
166
|
+
|
|
167
|
+
for archive_path in archives:
|
|
168
|
+
p, f = process_archive(archive_path, extract_one_func, writer=writer)
|
|
169
|
+
total_processed += p
|
|
170
|
+
total_failures += f
|
|
171
|
+
|
|
172
|
+
print(
|
|
173
|
+
f"\nDataset processado: {total_processed} áudios extraídos com sucesso, "
|
|
174
|
+
f"{total_failures} falhas. Salvo em: {output_path}"
|
|
175
|
+
)
|
|
176
|
+
return pd.read_csv(str(output_path))
|