Voiceprint Comparison

Phonexia voiceprint-comparison is a tool for comparing voiceprints obtained from audio recordings using Phonexia voiceprint-extraction. To learn more, visit the technology's home page.

Installation

Docker image

Getting voiceprint comparison docker image

You can easily obtain the voiceprint comparison docker image from docker hub. Just run:

docker pull phonexia/voiceprint-comparison:latest

Running the image

Docker

You can start the microservice and list all the supported options by running:

docker run --rm -it phonexia/voiceprint-comparison:latest --help

The output should look like this:

Usage: voiceprint-comparison [OPTIONS]

Options:
  -h,--help                   Print this help message and exit
  -m,--model file REQUIRED (Env:PHX_MODEL_PATH)
                              Path to a model file.
  -k,--license_key string REQUIRED (Env:PHX_LICENSE_KEY)
                              License key.
  -a,--listening_address address [[::]]  (Env:PHX_LISTENING_ADDRESS)
                              Address on which the server will be listening. Address '[::]' also accepts IPv4 connections.
  -p,--port number [8080]  (Env:PHX_PORT)
                              Port on which the server will be listening.
  -l,--log_level level:{error,warning,info,debug,trace} [info]  (Env:PHX_LOG_LEVEL)
                              Logging level. Possible values: error, warning, info, debug, trace.
  --keepalive_time_s number:[0, max_int] [60]  (Env:PHX_KEEPALIVE_TIME_S)
                              Time between 2 consecutive keep-alive messages, that are sent if there is no activity from the client. If set to 0, the default gRPC configuration (2hr) will be set (note, that this may get the microservice into unresponsive state).
  --keepalive_timeout_s number:[1, max int] [20]  (Env:PHX_KEEPALIVE_TIMEOUT_S)
                              Time to wait for keep alive acknowledgement until the connection is dropped by the server.

note

The model and license_key options are required. To obtain the model and license, contact Phonexia.

You can specify the options either via command line arguments or via environmental variables.

Run the container with the mandatory parameters:

docker run --rm -it -v /opt/phx/models:/models -p 8080:8080 /phonexia/voiceprint-comparison:latest --model /models/speaker_identification-xl-5.0.0.model --license_key ${license-key}

Replace the /opt/phx/models, speaker_identification-xl-5.0.0.model and license-key with the corresponding values.

With this command, the container will start, and the microservice will be listening on port 8080 on localhost.

Docker compose

Docker compose

Create a docker-compose.yml file:

version: '3'
services:
  voiceprint-comparison:
    image: phonexia/voiceprint-comparison:latest
    environment:
      - PHX_MODEL_PATH=/models/speaker_identification-xl-5.0.0.model
      - PHX_LICENSE_KEY=<license-key>
    ports:
      - 8080:8080
    volumes:
      - ./models:/models/

Create a models folder in the same directory as the docker-compose.yml file and place a model file in it. Replace <license-key> with your license key and speaker_identification-xl-5.0.0.model with the actual name of a model.

note

The model and license_key options are required. To obtain the model and license, contact Phonexia.

You can than start the microservice by running:

$ docker compose up

Helm chart

The optimal way for large scale deployment is by using container orchestration system. Take a look at out Helm chart deployment page for deployment using Kubernetes.

Microservice communication

gRPC API

For communication, our microservices use gRPC, which is a high-performance, open-source Remote Procedure Call (RPC) framework that enables efficient communication between distributed systems using a variety of programming languages. We use an interface definition language to specify a common interface and contracts between components. This is primarily achieved by specifying methods with parameters and return types.

Take a look at our gRPC API documentation. The voiceprint-comparison microservice defines a VoiceprintComparison service with remote procedure called Compare. This procedure performs M to N comparison of voiceprints. It accepts an argument (also referred to as "message") called CompareRequest containing two arrays of voiceprints for the comparison called voiceprints_a and voiceprints_b. This CompareRequest argument is streamed, meaning that it may be received in multiple requests, each containing some of the voiceprints. Once all requests have been received and processed, the Compare procedure returns a message called CompareResponse which consists of the resulting Matrix of scores.

Connecting to microservice

There are multiple ways how you can communicate with our microservices.

Generated library

Using generated library

The most common way how to communicate with the microservices is via a programming language using a generated library.

Python library

If you use Python as your programming language, you can use our official gRPC Python library.

To install the package using pip, run:

pip install phonexia-grpc

You can then import:

• Specific libraries for each microservice that provide the message wrappers.
• stubs for the gRPC clients.

from phonexia.grpc.common.core_pb2 import Voiceprint
from phonexia.grpc.technologies.speaker_identification.v1.speaker_identification_pb2 import CompareRequest, CompareResponse
from phonexia.grpc.technologies.speaker_identification.v1.speaker_identification_pb2_grpc import VoiceprintComparisonStub

Generate library for programming language of your choice

For the definition of microservice interfaces, we use the standard way of protocol buffers. The services, together with the procedures and messages that they expose, are defined in the so-called proto files.

The proto files can be used to generate client libraries in many programming languages. Take a look at protobuf tutorials for how to get started with generating the library in the languages of your choice using the protoc tool.

You can find the proto files developed by Phonexia in this repository.

Python client

Phonexia Python client

The easiest way to get started with testing is to use our simple Python client. To get it, run:

pip install phonexia-voiceprint-comparison-client

After the successful installation, run the following command to see the client options:

voiceprint_comparison_client --help

grpcurl client

grpcurl client

If you need a simple tool for testing the microservice on cmd line, you can use grpcurl. This tool will serialize and send a body that we define in json to an endpoint that we specify.

The body for grpcurl should look somewhat like this:

{
  "voiceprints_a": [
    {
      "content": "${voiceprint_1}"
    },
    ...
  ],
  "voiceprints_b": [
    {
      "content": "${voiceprint_2}"
    },
    ...
  ]
}

For this you already need to have extracted voiceprints. If you don't have any yet, you can obtain some using the Phonexia voiceprint-extraction microservice.

In the request, there may be multiple voiceprints in voiceprints_a as well as in voiceprints_b arrays.

Get such a request body with the following command.

echo -n '{"voiceprints_a": [{"content": "'$(cat ${path_to_voiceprint_1})'"}],"voiceprints_b": [{"content": "'$(cat ${path_to_voiceprint_2})'"}]}' > ${path_to_body}

Replace path_to_voiceprint_1, path_to_voiceprint_2 and path_to_body with corresponding values.

Now you can make the request. The microservice supports reflection. That means that you don't need to know the API in advance to make a request.

grpcurl -plaintext -use-reflection -d @ localhost:8080 phonexia.grpc.technologies.speaker_identification.v1.VoiceprintComparison/Compare < ${path_to_body}

The grpcurl automatically serializes the response to this request into JSON including the Matrix with the scores.

GUI clients

GUI clients

If you'd prefer to use a GUI client like Postman or Warthog to test the microservice, take a look at the GUI Client page in our documentation. Note that you will still need to convert the audio into the Base64 format manually as those tools do not support it by default either.

Further links

• Maintained by Phonexia
• Contact us via e-mail, or open a ticket at the Phonexia Service Desk
• File an issue
• See list of licenses
• See the terms of use

Versioning

We use Semantic Versioning.