BirdNET v2.4 (GLOBAL 6K) - ONNX variants

ONNX builds of the BirdNET GLOBAL 6K V2.4 bird sound classifier, optimized for edge deployment in BirdNET-Go. This repo holds the precision/backend variants; the stock upstream TFLite model is unchanged and not re-hosted here.

Powered by BirdNET (https://birdnet.cornell.edu/)

BirdNET is developed by the K. Lisa Yang Center for Conservation Bioacoustics at the Cornell Lab of Ornithology and Chemnitz University of Technology. These ONNX files are derived from the upstream BirdNET v2.4 model. Attribution to BirdNET is a hard license requirement: do not strip it.

Model summary

• Classes: 6,522 species (scientific + common name, see labels.txt)
• Sample rate: 48 kHz
• Clip length: 3 s (raw PCM waveform)
• Input tensor: input, float32, shape [batch, 144000] (3 s x 48 kHz)
• Output tensor: output, float32, shape [batch, 6522] (per-class logits; apply sigmoid for confidence scores in [0, 1])

All six files share an identical input/output interface, so they are drop-in replacements for one another. models.json lists each file's checksum, backend support and the recommended file per platform.

Variants

fp32_foldconv

The fold replaces the framing Gather, window multiply and two MatMuls of each spectrogram with a single strided 1-D Conv on the waveform, built with birdnet-onnx-converter --fold-frontend. The folded weights are computed in float64, but the summation order changes, so outputs are close to, not identical with, the unfolded build:

• 47,009 real-audio windows (2,597 recordings, 1.5 s hop): max logit difference 2.7e-3 against the same converter build without the fold, identical top-1 in every window, and no detection changes at thresholds 0.1 to 0.9 or sensitivities 0.75 to 1.5. Its max logit difference against the upstream TFLite model is 2.6e-3.
• OpenVINO 2026.2: about 26% faster than fp32_dfttrunc on an Intel CPU at f32. On an Intel iGPU it is about 10% slower, so fp32_dfttrunc stays the GPU choice. Do not run it on an Arm A76 at OpenVINO's default f16 hint: with a static [1, 144000] input shape, windows with most of their power below 150 Hz (wind) lose their scores. On 60 such windows a Pi 5 moved confidences by up to 0.39 against the TFLite model, and 4 fell to 0.00 (fp32_dfttrunc was worse). f32 and ONNX Runtime are clean; on the A76 ONNX Runtime is also faster than OpenVINO f32.

ONNX Runtime 1.31.1, ms per 3 s window at 1 / 4 threads:

Peak RSS is about 260 MB for both FP32 builds and about 247 MB for int8_arm_dfttrunc.

int8_arm_foldconv

fp32_foldconv with the 1024x6522 classification head quantized to INT8 (dynamic, MatMul only, no calibration data); the folded front end and all Conv layers stay FP32. It is built by applying the converter's --int8-arm quantization to the published fp32_foldconv file. The quantization costs a little accuracy, the same as in int8_arm_dfttrunc:

• 4,608 real-audio windows from 500 recordings, against the upstream TFLite model: max confidence difference 0.0225 (99.99th percentile 0.0024), top-1 agrees in 99.1% of windows and in all 1,513 windows where the TFLite top confidence is 0.5 or higher. About 1% of detections near the threshold flip (10 of 806 at 0.8), against 12 of 806 for int8_arm_dfttrunc on the same windows.
• 162 human-verified true-positive recordings: none lost its detection against the TFLite model at thresholds 0.3, 0.5 or 0.8.
• A Raspberry Pi 5 gives the same logits as x86 within 4.2e-3.

ONNX Runtime 1.31.1, ms per 3 s window at 1 / 4 threads, and peak RSS:

Run it on ONNX Runtime. It has not been tested on OpenVINO, and the stock INT8 build gave non-finite scores there at f16 on an Arm A76.

Precision notes

• CPU / ARM, low RAM: use int8_arm_foldconv. Full all-ops INT8 (ConvInteger) is not shipped: it breaks accuracy (~34% top-1) and has no fast ARM kernel. Only MatMul-only quantization of the head is accuracy-safe.
• OpenVINO: use an FP32 file, and on an Arm A76 prefer ONNX Runtime for BirdNET v2.4 (see fp32_foldconv above). The empty INFERENCE_PRECISION_HINT resolves to f16 on fp16-capable hardware (A76 NEON, AVX512-FP16) and to f32 elsewhere. Force INFERENCE_PRECISION_HINT=FP32 on GPU, where f16 miscompiles.
• f16 is intentionally not provided as a separate file: OpenVINO derives it from the FP32 master via the precision hint, and on CPU f16 uses more RAM than fp32 (the runtime up-converts f16 weights to f32 at load).

Note: this is the bird classifier. The BirdNET v2.4 backbone is also used as an embedding extractor for bat detection; that embedding model lives separately at tphakala/BattyBirdNET-onnx and must stay FP32 (its raw embedding output overflows at f16).

Labels

labels.txt has 6,522 lines, one per class, in BirdNET order. Format is Scientific name_Common name, for example:

Abroscopus albogularis_Rufous-faced Warbler

Output index i corresponds to line i of labels.txt.

Usage (ONNX Runtime, Python)

import numpy as np, onnxruntime as ort

sess = ort.InferenceSession("BirdNET_v2.4_fp32_foldconv.onnx")

# 3 s of 48 kHz mono PCM as float32, shape [1, 144000]
audio = np.zeros((1, 144000), dtype=np.float32)

logits = sess.run(["output"], {"input": audio})[0]   # [1, 6522]
conf = 1.0 / (1.0 + np.exp(-logits))                  # sigmoid -> [0, 1]
labels = open("labels.txt").read().splitlines()
top = conf[0].argmax()
print(labels[top], float(conf[0, top]))

Checksums

See SHA256SUMS and models.json.

License

BirdNET v2.4 is distributed under CC BY-NC-SA 4.0 (non-commercial, share-alike, attribution required). See LICENSE and keep the BirdNET attribution above with any use or redistribution.

Source

• Upstream: birdnet-team/BirdNET-Analyzer
• ONNX conversion and optimization: tphakala/birdnet-onnx-converter
• Catalog and deployment: tphakala/birdnet-go