insect-audio-features 0.1.0__tar.gz
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-0.1.0/MANIFEST.in +12 -0
- insect_audio_features-0.1.0/PACKAGE_README.md +58 -0
- insect_audio_features-0.1.0/PKG-INFO +75 -0
- insect_audio_features-0.1.0/README.md +174 -0
- insect_audio_features-0.1.0/insect_audio_features/__init__.py +10 -0
- insect_audio_features-0.1.0/insect_audio_features.egg-info/PKG-INFO +75 -0
- insect_audio_features-0.1.0/insect_audio_features.egg-info/SOURCES.txt +15 -0
- insect_audio_features-0.1.0/insect_audio_features.egg-info/dependency_links.txt +1 -0
- insect_audio_features-0.1.0/insect_audio_features.egg-info/requires.txt +6 -0
- insect_audio_features-0.1.0/insect_audio_features.egg-info/top_level.txt +3 -0
- insect_audio_features-0.1.0/main.py +68 -0
- insect_audio_features-0.1.0/pyproject.toml +33 -0
- insect_audio_features-0.1.0/setup.cfg +4 -0
- insect_audio_features-0.1.0/src/extractors/librosa.py +124 -0
- insect_audio_features-0.1.0/src/extractors/padrao.py +162 -0
- insect_audio_features-0.1.0/src/utils/dataset_processor.py +176 -0
- insect_audio_features-0.1.0/tests/test_package.py +48 -0
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
include PACKAGE_README.md
|
|
2
|
+
include pyproject.toml
|
|
3
|
+
include main.py
|
|
4
|
+
recursive-include insect_audio_features *.py
|
|
5
|
+
recursive-include src/extractors *.py
|
|
6
|
+
recursive-include src/utils *.py
|
|
7
|
+
recursive-include tests *.py
|
|
8
|
+
prune data
|
|
9
|
+
prune features
|
|
10
|
+
prune results
|
|
11
|
+
prune documentoIC
|
|
12
|
+
prune src/classification
|
|
@@ -0,0 +1,58 @@
|
|
|
1
|
+
# Insect Audio Features
|
|
2
|
+
|
|
3
|
+
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).
|
|
4
|
+
|
|
5
|
+
## Instalação
|
|
6
|
+
|
|
7
|
+
Após publicação no PyPI:
|
|
8
|
+
|
|
9
|
+
```bash
|
|
10
|
+
pip install insect-audio-features
|
|
11
|
+
```
|
|
12
|
+
|
|
13
|
+
Para desenvolvimento, na raiz do repositório:
|
|
14
|
+
|
|
15
|
+
```bash
|
|
16
|
+
pip install -e .
|
|
17
|
+
```
|
|
18
|
+
|
|
19
|
+
## Uso
|
|
20
|
+
|
|
21
|
+
```python
|
|
22
|
+
from insect_audio_features import extract_features, get_feature_columns_librosa
|
|
23
|
+
|
|
24
|
+
print(get_feature_columns_librosa())
|
|
25
|
+
|
|
26
|
+
df = extract_features(
|
|
27
|
+
path_dataset='Aedes aegypti (female).zip',
|
|
28
|
+
path_output='resultados/librosa.csv',
|
|
29
|
+
biblioteca='librosa',
|
|
30
|
+
)
|
|
31
|
+
print(df.head())
|
|
32
|
+
```
|
|
33
|
+
|
|
34
|
+
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`.
|
|
35
|
+
|
|
36
|
+
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.
|
|
37
|
+
|
|
38
|
+
## Métodos
|
|
39
|
+
|
|
40
|
+
- **Librosa:** RMS, cruzamento por zero, centroide, largura de banda, planicidade, roll-off, sete bandas de contraste e 13 MFCCs (26 atributos).
|
|
41
|
+
- **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.
|
|
42
|
+
|
|
43
|
+
Também é possível processar um WAV individual:
|
|
44
|
+
|
|
45
|
+
```python
|
|
46
|
+
from insect_audio_features import extract_features_librosa
|
|
47
|
+
features = extract_features_librosa('audio.wav')
|
|
48
|
+
```
|
|
49
|
+
|
|
50
|
+
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.
|
|
51
|
+
|
|
52
|
+
## Escopo
|
|
53
|
+
|
|
54
|
+
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.
|
|
55
|
+
|
|
56
|
+
## Organização preservada
|
|
57
|
+
|
|
58
|
+
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,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,174 @@
|
|
|
1
|
+
# Insect Audio Feature Benchmark
|
|
2
|
+
|
|
3
|
+
Benchmark e avaliação de bibliotecas Python para extração de atributos acústicos em sinais optoacústicos de insetos alados (vetores de doenças como *Aedes aegypti*, *Culex*, *Anopheles*, entre outros).
|
|
4
|
+
|
|
5
|
+
O objetivo deste projeto de Iniciação Científica (IC) é comparar a performance computacional, precisão e qualidade dos atributos gerados por diferentes bibliotecas de áudio em relação ao método padrão (baseline) do laboratório, visando aplicações em Machine Learning para classificação taxonômica de espécies e sexagem.
|
|
6
|
+
|
|
7
|
+
---
|
|
8
|
+
|
|
9
|
+
## 📋 Bibliotecas Avaliadas
|
|
10
|
+
|
|
11
|
+
O benchmark abrange e compara diversas bibliotecas do ecossistema de processamento de áudio em Python:
|
|
12
|
+
|
|
13
|
+
* **Padrão (Baseline do Laboratório)**: Método de referência com 38 atributos espectrais e temporais (frequência de batimento de asas - WBF via Cepstrum, temperatura dos sensores, complexidade do sinal, harmônicos `eh_1` a `eh_26`, inarmonicidade e picos de frequência).
|
|
14
|
+
* **Librosa**: Biblioteca padrão de mercado para recuperação de informação musical e análise acústica.
|
|
15
|
+
* **AudioFlux**: Biblioteca de alta performance em C/Python focada em representações tempo-frequência.
|
|
16
|
+
* **Essentia**: Algoritmos C++ de alta performance para análise e extração de descritores de áudio.
|
|
17
|
+
* **OpenSMILE**: Padrão na extração de features para reconhecimento de voz e paralinguística.
|
|
18
|
+
* **TSFEL**: Biblioteca voltada para extração de atributos em séries temporais.
|
|
19
|
+
* **PyAudioAnalysis**, **TorchAudio**, **SPAFE**, **Surfboard**, entre outras.
|
|
20
|
+
|
|
21
|
+
---
|
|
22
|
+
|
|
23
|
+
## 📂 Estrutura do Repositório
|
|
24
|
+
|
|
25
|
+
```
|
|
26
|
+
insect-audio-feature-benchmark/
|
|
27
|
+
├── data/
|
|
28
|
+
│ ├── raw/
|
|
29
|
+
│ │ └── females/ # Áudios ZIP de fêmeas (Aedes, Culex, etc.)
|
|
30
|
+
│ └── others/
|
|
31
|
+
│ └── males/ # Áudios ZIP de machos
|
|
32
|
+
├── features/ # CSVs gerados com os atributos por biblioteca
|
|
33
|
+
│ ├── padrao/
|
|
34
|
+
│ │ └── padrao.csv # Atributos extraídos pelo método baseline
|
|
35
|
+
│ ├── librosa/
|
|
36
|
+
│ ├── audioflux/
|
|
37
|
+
│ └── ...
|
|
38
|
+
├── src/
|
|
39
|
+
│ ├── extractors/ # Módulos puros de extração (1 áudio -> dicionário)
|
|
40
|
+
│ │ └── padrao.py # Baseline com os 38 atributos do laboratório
|
|
41
|
+
│ ├── utils/
|
|
42
|
+
│ │ └── auxiliares.py # Pipeline de dados (busca ZIPs, extração e CSV)
|
|
43
|
+
│ ├── preprocessing/ # Pré-processamento e filtragem de sinais
|
|
44
|
+
│ ├── classification/ # Modelos de Machine Learning para classificação
|
|
45
|
+
│ └── evaluation/ # Métricas comparativas de acurácia e tempo
|
|
46
|
+
├── main.py # Ponto de entrada do benchmark
|
|
47
|
+
├── requirements.txt # Dependências do projeto
|
|
48
|
+
└── README.md
|
|
49
|
+
```
|
|
50
|
+
|
|
51
|
+
---
|
|
52
|
+
|
|
53
|
+
## 🏗️ Arquitetura e Filosofia do Projeto
|
|
54
|
+
|
|
55
|
+
O projeto adota uma arquitetura modular com separação clara de responsabilidades:
|
|
56
|
+
|
|
57
|
+
1. **Extratores Puros (`src/extractors/`)**:
|
|
58
|
+
- Cada biblioteca possui seu próprio arquivo (ex.: `padrao.py`, futuro `librosa_ext.py`).
|
|
59
|
+
- O extrator é responsável **exclusivamente** pelo processamento de sinal: recebe o caminho de **1 arquivo `.wav`** e devolve um dicionário Python contendo as features numéricas calculadas.
|
|
60
|
+
- Não se preocupa com pastas, descompactação de ZIPs ou geração de CSV.
|
|
61
|
+
|
|
62
|
+
2. **Orquestração de Dados (`src/utils/auxiliares.py`)**:
|
|
63
|
+
- Descobre automaticamente os arquivos `.zip` no disco.
|
|
64
|
+
- Extrai o nome da espécie/sexo diretamente do nome do arquivo (`get_labels`).
|
|
65
|
+
- Descompacta os áudios temporariamente em memória/disco seguro (`get_wav_members`).
|
|
66
|
+
- Executa a função do extrator escolhido para cada áudio e salva os resultados em lote no CSV final (`process_dataset`).
|
|
67
|
+
|
|
68
|
+
3. **Interface do Usuário (`main.py`)**:
|
|
69
|
+
- Ponto de entrada simplificado. O usuário define qual dataset processar, o arquivo de saída e a biblioteca desejada via `extract_features(...)`.
|
|
70
|
+
|
|
71
|
+
---
|
|
72
|
+
|
|
73
|
+
## 🚀 Como Executar
|
|
74
|
+
|
|
75
|
+
### 1. Pré-requisitos
|
|
76
|
+
* Python 3.10 ou superior (recomendado Python 3.13)
|
|
77
|
+
* Ambiente virtual configurado
|
|
78
|
+
|
|
79
|
+
### 2. Instalação do Ambiente
|
|
80
|
+
|
|
81
|
+
Crie e ative um ambiente virtual:
|
|
82
|
+
|
|
83
|
+
```bash
|
|
84
|
+
python -m venv .venv
|
|
85
|
+
source .venv/bin/activate # No Linux/macOS
|
|
86
|
+
# ou: .venv\Scripts\activate no Windows
|
|
87
|
+
```
|
|
88
|
+
|
|
89
|
+
Instale as dependências:
|
|
90
|
+
|
|
91
|
+
```bash
|
|
92
|
+
pip install -r requirements.txt
|
|
93
|
+
```
|
|
94
|
+
|
|
95
|
+
*(Opcional - Usando [uv](https://github.com/astral-sh/uv) para instalação ultra-rápida):*
|
|
96
|
+
```bash
|
|
97
|
+
uv venv --python 3.13 .venv
|
|
98
|
+
source .venv/bin/activate
|
|
99
|
+
uv pip install -r requirements.txt
|
|
100
|
+
```
|
|
101
|
+
|
|
102
|
+
### 3. Executando a Extração
|
|
103
|
+
|
|
104
|
+
Para rodar a extração dos atributos de todas as amostras, basta executar:
|
|
105
|
+
|
|
106
|
+
```bash
|
|
107
|
+
python main.py
|
|
108
|
+
```
|
|
109
|
+
|
|
110
|
+
Exemplo de uso via código em `main.py`:
|
|
111
|
+
|
|
112
|
+
```python
|
|
113
|
+
from main import extract_features
|
|
114
|
+
|
|
115
|
+
df = extract_features(
|
|
116
|
+
path_dataset="data/raw/females",
|
|
117
|
+
path_output="features/padrao/padrao.csv",
|
|
118
|
+
biblioteca="padrao",
|
|
119
|
+
)
|
|
120
|
+
|
|
121
|
+
print(f"Total de áudios processados: {len(df)}")
|
|
122
|
+
print(df.head())
|
|
123
|
+
```
|
|
124
|
+
|
|
125
|
+
---
|
|
126
|
+
|
|
127
|
+
## 📊 Dataset
|
|
128
|
+
|
|
129
|
+
Os dados consistem em arquivos `.zip` gravados por sensores optoacústicos ópticos (dispositivos de barreira de luz infravermelha), contendo arquivos `.wav` individuais:
|
|
130
|
+
|
|
131
|
+
* **Espécies presentes**:
|
|
132
|
+
* *Aedes aegypti* (fêmeas e machos)
|
|
133
|
+
* *Aedes albopictus* (fêmeas e machos)
|
|
134
|
+
* *Anopheles aquasalis* (fêmeas e machos)
|
|
135
|
+
* *Culex quinquefasciatus* (fêmeas e machos)
|
|
136
|
+
* *Culex tarsalis* (fêmeas e machos)
|
|
137
|
+
* *Drosophila suzukii* (fêmeas e machos)
|
|
138
|
+
* **Metadados gravados**:
|
|
139
|
+
* Temperatura (°C) registrada no momento da captura presente nos comentários do cabeçalho WAV (`T=...`).
|
|
140
|
+
* Taxa de amostragem padrão: 44.1 kHz.
|
|
141
|
+
|
|
142
|
+
---
|
|
143
|
+
|
|
144
|
+
## 🧩 Como Adicionar uma Nova Biblioteca
|
|
145
|
+
|
|
146
|
+
Para adicionar uma nova biblioteca ao benchmark (por exemplo, `librosa`):
|
|
147
|
+
|
|
148
|
+
1. Crie o módulo em `src/extractors/librosa_ext.py`:
|
|
149
|
+
```python
|
|
150
|
+
import librosa
|
|
151
|
+
|
|
152
|
+
def extract_features_librosa(audio_path: str) -> dict[str, float]:
|
|
153
|
+
audio, sr = librosa.load(audio_path, sr=44100)
|
|
154
|
+
|
|
155
|
+
# Exemplo de atributos
|
|
156
|
+
mfccs = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=13)
|
|
157
|
+
centroid = librosa.feature.spectral_centroid(y=audio, sr=sr)
|
|
158
|
+
|
|
159
|
+
return {
|
|
160
|
+
"spectral_centroid_mean": float(centroid.mean()),
|
|
161
|
+
**{f"mfcc_{i+1}": float(mfccs[i].mean()) for i in range(13)},
|
|
162
|
+
}
|
|
163
|
+
```
|
|
164
|
+
|
|
165
|
+
2. Adicione a chamada no `main.py`:
|
|
166
|
+
```python
|
|
167
|
+
elif biblioteca_norm == "librosa":
|
|
168
|
+
return process_dataset(
|
|
169
|
+
data_dirs=path_dataset,
|
|
170
|
+
output_csv=path_output,
|
|
171
|
+
extract_one_func=extract_features_librosa,
|
|
172
|
+
)
|
|
173
|
+
```
|
|
174
|
+
O pipeline cuidará de descompactar, rotular e gerar o CSV correspondente em `features/librosa/librosa.csv`.
|
|
@@ -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,15 @@
|
|
|
1
|
+
MANIFEST.in
|
|
2
|
+
PACKAGE_README.md
|
|
3
|
+
README.md
|
|
4
|
+
main.py
|
|
5
|
+
pyproject.toml
|
|
6
|
+
insect_audio_features/__init__.py
|
|
7
|
+
insect_audio_features.egg-info/PKG-INFO
|
|
8
|
+
insect_audio_features.egg-info/SOURCES.txt
|
|
9
|
+
insect_audio_features.egg-info/dependency_links.txt
|
|
10
|
+
insect_audio_features.egg-info/requires.txt
|
|
11
|
+
insect_audio_features.egg-info/top_level.txt
|
|
12
|
+
src/extractors/librosa.py
|
|
13
|
+
src/extractors/padrao.py
|
|
14
|
+
src/utils/dataset_processor.py
|
|
15
|
+
tests/test_package.py
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
|
|
@@ -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,33 @@
|
|
|
1
|
+
[build-system]
|
|
2
|
+
requires = ["setuptools>=77"]
|
|
3
|
+
build-backend = "setuptools.build_meta"
|
|
4
|
+
|
|
5
|
+
[project]
|
|
6
|
+
name = "insect-audio-features"
|
|
7
|
+
version = "0.1.0"
|
|
8
|
+
description = "Python feature extraction for insect optoacoustic signals"
|
|
9
|
+
readme = "PACKAGE_README.md"
|
|
10
|
+
requires-python = ">=3.10"
|
|
11
|
+
authors = [{name = "Gabriel Cavalcante Velasquez"}]
|
|
12
|
+
keywords = ["insects", "optoacoustic", "audio", "feature-extraction", "librosa"]
|
|
13
|
+
dependencies = [
|
|
14
|
+
"numpy>=1.24,<3",
|
|
15
|
+
"pandas>=2,<4",
|
|
16
|
+
"scipy>=1.10,<2",
|
|
17
|
+
"librosa>=0.11,<2",
|
|
18
|
+
"audioflux>=0.1.9,<0.2",
|
|
19
|
+
"audio-metadata>=0.11.1,<0.12",
|
|
20
|
+
]
|
|
21
|
+
|
|
22
|
+
[project.urls]
|
|
23
|
+
Repository = "https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark"
|
|
24
|
+
Issues = "https://github.com/GabrielCavalcanteVelasquez/insect-audio-feature-benchmark/issues"
|
|
25
|
+
|
|
26
|
+
[tool.setuptools]
|
|
27
|
+
py-modules = ["main"]
|
|
28
|
+
include-package-data = false
|
|
29
|
+
|
|
30
|
+
[tool.setuptools.packages.find]
|
|
31
|
+
where = ["."]
|
|
32
|
+
include = ["insect_audio_features", "src.extractors", "src.utils"]
|
|
33
|
+
namespaces = true
|
|
@@ -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
|
|
@@ -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))
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
"""Integração da API instalada com ZIP e WAV sintéticos."""
|
|
2
|
+
import csv
|
|
3
|
+
import io
|
|
4
|
+
import math
|
|
5
|
+
import tempfile
|
|
6
|
+
import unittest
|
|
7
|
+
import wave
|
|
8
|
+
import zipfile
|
|
9
|
+
from pathlib import Path
|
|
10
|
+
|
|
11
|
+
import numpy as np
|
|
12
|
+
import insect_audio_features as api
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
class PackageTests(unittest.TestCase):
|
|
16
|
+
def test_public_api(self):
|
|
17
|
+
self.assertEqual(len(api.get_feature_columns_librosa()), 26)
|
|
18
|
+
with self.assertRaises(ValueError):
|
|
19
|
+
api.extract_features('unused.zip', 'unused.csv', 'invalid')
|
|
20
|
+
|
|
21
|
+
def test_zip_extraction(self):
|
|
22
|
+
samples = (np.sin(2 * np.pi * 440 * np.arange(22050) / 44100) * 12000).astype('<i2')
|
|
23
|
+
audio = io.BytesIO()
|
|
24
|
+
with wave.open(audio, 'wb') as stream:
|
|
25
|
+
stream.setparams((1, 2, 44100, 0, 'NONE', 'not compressed'))
|
|
26
|
+
stream.writeframes(samples.tobytes())
|
|
27
|
+
with tempfile.TemporaryDirectory() as temp:
|
|
28
|
+
root = Path(temp)
|
|
29
|
+
archive = root / 'Aedes aegypti (female).zip'
|
|
30
|
+
with zipfile.ZipFile(archive, 'w') as zipped:
|
|
31
|
+
zipped.writestr('signal.wav', audio.getvalue())
|
|
32
|
+
for method in ('padrao', 'librosa'):
|
|
33
|
+
output = root / method / 'attributes.csv'
|
|
34
|
+
frame = api.extract_features(archive, output, method)
|
|
35
|
+
self.assertEqual(len(frame), 1)
|
|
36
|
+
self.assertEqual(list(frame.columns), ['zip_name', 'file_path', 'label'] + (api.get_feature_columns() if method == 'padrao' else api.get_feature_columns_librosa()))
|
|
37
|
+
self.assertEqual(frame.iloc[0]['label'], 'Aedes aegypti (female)')
|
|
38
|
+
with output.open() as stream:
|
|
39
|
+
self.assertEqual(len(list(csv.DictReader(stream))), 1)
|
|
40
|
+
if method == 'librosa':
|
|
41
|
+
self.assertAlmostEqual(frame.iloc[0]['rms'], 12000 / 32768 / math.sqrt(2), delta=.02)
|
|
42
|
+
else:
|
|
43
|
+
self.assertAlmostEqual(frame.iloc[0]['time_length'], .5)
|
|
44
|
+
self.assertTrue(math.isfinite(frame.iloc[0]['wbf']))
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
if __name__ == '__main__':
|
|
48
|
+
unittest.main()
|