Who
Rotule os locutores de uma gravação e veja exatamente quando cada pessoa começa e para de falar, inteiramente no dispositivo.
Marque quem disse o quê em áudio e vídeo.
O Who foi feito para podcasts, entrevistas, chamadas e reuniões, e lida com gravações de qualquer duração. Uma entrevista de 50 minutos leva 3 s em um MacBook Pro, inteiramente no dispositivo. Use as marcações de tempo para separar uma transcrição por locutor, pular para a próxima fala de um convidado ou cortar a cada troca de locutor.
O Who numera os locutores na ordem em que falam pela primeira vez e, quando duas pessoas falam ao mesmo tempo, marca as duas. O Who processa cada trecho de cinco minutos em uma única passada e associa as vozes de um trecho a outro.
Nas gravações de reuniões do AMI, o Who rotula os locutores com uma taxa de erro de 12,6%, abaixo dos 13,1% do pyannote em uma GPU de servidor e dos 19,4% do FluidAudio no mesmo Mac. O Who também roda duas vezes mais rápido que o FluidAudio.
Uma hora de áudio em 4 s.
O Who roda a 950x o tempo real em um MacBook Pro com M5 Pro, pelo SDK. Nas reuniões do AMI, a taxa de erro de diarização do Who é de 12,6%, contra 13,1% do pyannote e 19,4% do FluidAudio.
Conjuntos de teste completos em um MacBook Pro (M5 Pro), uma gravação por vez. Os tempos do Who incluem o carregamento do modelo. No AMI, o FluidAudio leva 73 s pelo próprio cronômetro e 79 s contando o carregamento dos modelos.
| Conjunto de teste | Tempo (Who) | Fator de tempo real (Who) | Fator de tempo real (FluidAudio) |
|---|---|---|---|
| AMI test, 544 minutes | 34 s | 950x | 445x |
| VoxConverse test, 43.5 hours | 165 s | 948x | 426x |
Taxa de erro de diarização em gravações inteiras (quanto menor, melhor). As mesmas gravações e a mesma ferramenta de pontuação em todas as linhas
| Modelo | AMI | VoxConverse, até 4 locutores | NOTSOFAR-1, até 4 locutores | Earnings-21 | DiPCo |
|---|---|---|---|---|---|
| Who, on the Neural Engine | 12,6% | 8,4% | 16,2% | 27,7% | 41,1% |
| pyannote community-1, PyTorch | 13,1% | 7,3% | 18,7% | 7,3% | 33,4% |
| FluidAudio, Core ML | 19,4% | 9,6% | 32,7% | 12,0% | 42,7% |
O Who lidera nos dois conjuntos de reuniões, AMI e NOTSOFAR-1, e fica atrás do pyannote nos outros três: as teleconferências do Earnings-21 chegam a 20 locutores, e o Who tem 24,7% de erro no VoxConverse com nove ou mais locutores. O pyannote rodou em GPUs de servidor; o Who e o FluidAudio rodaram no Neural Engine do M5 Pro. Os resultados do pyannote e do FluidAudio vêm de execuções nossas e não constam do cartão do modelo.
Casos de uso
Marque quem disse o quê em áudio e vídeo.
Separe uma transcrição por locutor
Combine o Who com o Voz, e cada linha da transcrição mostra quem falou. Quem lê acompanha a conversa, em vez de um único bloco de texto anônimo.
Pule para a próxima fala do convidado
Filtre uma entrevista ou reunião de duas horas por locutor e vá direto às falas dessa pessoa, em vez de arrastar a linha do tempo. A gravação fica no dispositivo.
Corte a cada troca de locutor
Troque o ângulo de câmera em uma entrevista com duas câmeras ou em um podcast em vídeo sempre que o locutor mudar. Cada turno tem um início e um fim marcados, então cada troca de locutor é um ponto de corte.
Deixe as risadas de fora
Descarte as risadas da plateia e a voz que disse uma única frase do outro lado da sala. O Who deixa de fora todo locutor com participação na gravação abaixo do mínimo que você definir e renumera os demais.
O que o modelo faz
- O Who rotula até quatro locutores em cada trecho de cinco minutos, e mais ao longo de uma gravação inteira, associando as vozes entre os trechos.
- Cada turno é um intervalo contínuo de fala de um único locutor, com o número do locutor e os tempos de início e fim em segundos, com resolução de 10 ms. Os turnos de locutores diferentes se sobrepõem quando as pessoas falam umas por cima das outras.
- No SDK, o Who numera os locutores a partir de zero, na ordem em que falam pela primeira vez, e não identifica ninguém pelo nome.
- Dois grafos Core ML no Neural Engine leem cada trecho: um encoder e um grafo de queries. Um terceiro grafo cria uma impressão vocal de cada locutor a partir dos momentos em que a pessoa fala sozinha, e o Who associa todos os locutores da gravação inteira de uma só vez.
- Um locutor que fala sozinho por menos de um segundo não tem impressão vocal própria e é incorporado ao locutor mais próximo no tempo. Um segundo de risada no meio do turno de outro locutor fica com esse locutor.
- 950x o tempo real em um MacBook Pro com M5 Pro, pelo SDK: 544 minutos de reuniões do AMI em 34 s. A build de 8 bits roda a 953x.
- Uso de memória pelo SDK: 275 MB com o modelo carregado, e pico de 336 MB em uma gravação de 8 minutos, 437 MB em uma de 34 minutos e 927 MB em uma de 2,65 horas.
- O download Core ML tem 81 MB em float16 ou 42 MB com pesos de 8 bits, e as duas builds têm a mesma taxa de erro nas reuniões do AMI: 12,6%. A build de 8 bits não economiza memória, porque o Neural Engine descomprime os pesos ao carregar.
- O Who também está disponível como build LiteRT de 49 MB, que o SDK roda no Android, no Linux e no Windows, e como build ONNX de 99 MB, que os SDKs ainda não executam. Só na CPU, a build LiteRT processa 544 minutos de áudio em 87 s no M5 Pro e em 191 s em um servidor AMD EPYC de 24 núcleos, em medições feitas fora do SDK.
keepingSpeakers(minimumShare:)descarta todo locutor com participação na gravação abaixo de um mínimo e renumera os demais, assim risadas, aplausos e vinhetas saem do resultado. Com 5%, o filtro eliminou as risadas e a plateia nos podcasts que testamos. Para um programa de notícias com muitos locutores breves, use um mínimo baixo ou desative o filtro.- Faça a diarização de um arquivo de áudio por URL ou caminho, ou passe amostras mono em qualquer taxa de amostragem. O SDK faz a conversão da taxa para você.
- O SDK baixa os pesos do Hugging Face no primeiro uso e os guarda em cache.
download(progress:)busca os pesos com antecedência, eWho(directory:)roda offline a partir de uma pasta que você gerencia.
Primeiros passos
Adicione quem disse o quê ao seu app iOS or macOS or Android em poucas linhas de código. Docs do Who.
// Swift Package Manager
.package(url: "https://github.com/Desert-Ant-Labs/desert-ant-core.git", from: "4.0.0")
// target dependency
.product(name: "Who", package: "desert-ant-core")import Who
let who = Who() // downloads on first use
let result = try await who.diarize(contentsOf: url)
result.speakerCount // 3
for turn in result.turns {
print(turn.speaker, turn.start, turn.end) // 0 12.4 15.9
}Add Who from Desert Ant Labs to this Swift project (iOS, macOS). What it does: rotulagem de locutores no dispositivo para áudio e vídeo. SDK: Swift (iOS, macOS) Repo: https://github.com/Desert-Ant-Labs/desert-ant-core#readme // Swift Package Manager .package(url: "https://github.com/Desert-Ant-Labs/desert-ant-core.git", from: "4.0.0") // target dependency .product(name: "Who", package: "desert-ant-core") Reference: - Model page: https://desertant.com/models/who/ - Full catalog and other models: https://desertant.com/llms.txt Add the SDK, then follow its README for the exact API and current version. Do not invent API names or method signatures; confirm them against the README.
// build.gradle.kts (Maven Central)
implementation("ai.desertant:who:4.0.0")import ai.desertant.who.Who
val who = Who(context) // downloads on first use
val result = who.diarize(samples, 16_000.0)
result.speakerCount // 3
for (turn in result.turns) {
println("${turn.speaker} ${turn.start} ${turn.end}") // 0 12.4 15.9
}
who.close()Add Who from Desert Ant Labs to this Kotlin project (Android).
What it does: rotulagem de locutores no dispositivo para áudio e vídeo.
SDK:
Kotlin (Android)
Repo: https://github.com/Desert-Ant-Labs/desert-ant-core#readme
// build.gradle.kts (Maven Central)
implementation("ai.desertant:who:4.0.0")
Reference:
- Model page: https://desertant.com/models/who/
- Full catalog and other models: https://desertant.com/llms.txt
Add the SDK, then follow its README for the exact API and current version. Do not invent API names or method signatures; confirm them against the README.
Especificações
- Velocidade
- 950x o tempo real em um MacBook Pro (M5 Pro), uma entrevista de 50 minutos em 3 s
- Acurácia
- Taxa de erro de diarização de 12,6% nas reuniões do AMI; 8,4% no VoxConverse com até 4 locutores
- Locutores
- Até 4 em cada trecho de cinco minutos, mais ao longo de uma gravação de qualquer duração
- Saída
- Turnos por locutor com tempos de início e fim em segundos, com resolução de 10 ms; fala sobreposta preservada
- Tamanho no dispositivo
- 81 MB em Core ML (float16, padrão); 42 MB com pesos de 8 bits
- Memória
- 275 MB com o modelo carregado; pico de 927 MB em uma gravação de 2,65 horas
- Plataformas
- iOS 18+, macOS 15+, tvOS 18+, visionOS 2+ (Core ML); Android, Linux e Windows (LiteRT, na CPU)
O Who funciona melhor com áudio captado de perto, como podcasts, entrevistas e chamadas remotas em que cada pessoa tem o próprio microfone. Longe do microfone, o Who deixa de detectar mais fala: de 19% a 21% em conversas em grupo gravadas por um microfone do outro lado da sala, contra 8% em reuniões com headset.
Onde o Who mais deixa de detectar fala é quando duas vozes se sobrepõem. No VoxConverse, a taxa de erro é de 8% com um ou dois locutores, 17% com cinco a oito e 25% com nove ou mais.
Nas teleconferências de resultados do Earnings-21, com até 20 locutores fazendo intervenções curtas, o Who atribui 16% da fala ao locutor errado. O Who rotula os locutores por número, não por nome, e não transcreve; para uma transcrição separada por locutor, combine o Who com o Voz.
No Android, no Linux e no Windows, o Who roda na CPU, de três a sete vezes mais devagar do que no Neural Engine. O Who ainda não roda no navegador nem no Node.
FAQ
O que é o Who?
Rotule os locutores de uma gravação e veja exatamente quando cada pessoa começa e para de falar, inteiramente no dispositivo.
O Who roda no dispositivo?
Sim. O Who roda no dispositivo, sem chamada a servidor, então os dados ficam com o usuário.
Quais plataformas o Who suporta?
O Who é distribuído como um SDK nativo no dispositivo para Swift, Kotlin.
Quanto custa o Who?
Cada modelo é gratuito para até 100 mil dispositivos ativos mensais. A inferência é ilimitada. Fale conosco para licenças personalizadas.
Qual a precisão e a velocidade do Who?
O Who roda a 950x o tempo real em um MacBook Pro com M5 Pro, pelo SDK. Nas reuniões do AMI, a taxa de erro de diarização do Who é de 12,6%, contra 13,1% do pyannote e 19,4% do FluidAudio.