Language identification

Phonexia language-identification is a tool for calculating the probabilities of individual languages appearing in an audio recording. To learn more about the technology, visit this link.

Versioning

We use SemVer for versioning.

Quick reference

• Maintained by Phonexia
• Contact us via e-mail, or using Phonexia Service Desk
• File an issue
• See list of licenses
• See terms of use

How to use this image

Getting the image

You can easily obtain the docker image from docker hub. There are 2 variants of the image. One for CPU, one for GPU with tag ending with gpu.

To get the latest CPU image, run:

docker pull phonexia/language-identification:latest

To get the latest GPU image, run:

docker pull phonexia/language-identification:gpu

Running the image

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

docker run --rm -it phonexia/language-identification:latest --help

The output should look like this:

Usage: language-identification [OPTIONS]

Options:
  -h,--help                   Print this help message and exit
  -m,--model file/dir REQUIRED (Env:PHX_MODEL_PATH)
                              Path to model file or directory.
  -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 [info]  (Env:PHX_LOG_LEVEL)
                              Logging level. Possible values: error, warning, info, debug, trace.
  --device TEXT:{cpu,cuda} [cpu]  (Env:PHX_DEVICE)
                              Compute device used for inference.

Note that 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 ${absolute-path-to-models}:/models phonexia/language-identification:latest --model /models/${model} --license_key ${license-key}

Replace the absolute-path-to-models, 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.

Performance optimization

The language-identification microservice supports GPU acceleration to enhance performance.

GPU acceleration is enabled by default in the GPU-enabled image. This image requires a CUDA-enabled GPU in the system. While primarily GPU acceleration will be utilized, specific processing tasks will still rely on CPU resources.

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 language-identification microservice defines a LanguageIdentification service with remote procedures called Identify and ListSupportedLanguages. The Identify procedure accepts an argument (also referred to as "message") called IdentifyRequest, which contains the audio as an array of bytes, together with an optional config argument.

The config argument is used for controlling the identification parameters. In this argument, we can specify the amount of speech that will be used for the identification as well as all the languages from the set of supported languages that will be included in the identification. This way we can select only a subset of all the available languages. Finally, we can define a language groups, that group several languages and assigns them common identifier.

This IdentifyRequest argument is streamed, meaning that it may be received in multiple requests, each containing a part of the audio. If specified, the optional config argument must be sent only with the first request. Once all requests have been received and processed, the Identify procedure returns a message called IdentifyResponse which consists of the resulting language probability scores.

Connecting to microservice

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

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 gRPC Python library.

To get this library, simply run:

pip install phonexia-grpc

You can then import:

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

# phx_core contains classes common for multiple microservices like `Audio`.
import phonexia.grpc.common.core_pb2 as phx_core
# language_identification_pb2 contains `IdentifyRequest`, `IdentifyResponse` or 'IdentifyConfig'.
import phonexia.grpc.technologies.language_identification.v1.language_identification_pb2 as lid
# language_identification_pb2_grpc contains `LanguageIdentificationStub` needed to make the requests.
import phonexia.grpc.technologies.language_identification.v1.language_identification_pb2_grpc as lid_grpc

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.

Using existing clients

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-language-identification-client

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

language_identification_client --help

grpcurl client

If you need a simple tool for testing the microservice on the command line, you can use grpcurl. This tool can serialize and send a request for you, if you provide the request body in JSON format and specify the endpoint.

You need to make sure that the audio content in the body is encoded in Base64. Unfortunately you need to do this manually as grpcurl can't do this for you.

echo -n '{"audio": {"content": "'$(base64 -w0 < ${path_to_audio_file})'"}}' > ${path_to_body}

Replace path_to_audio_file 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.language_identification.v1.LanguageIdentification/Identify < ${path_to_body}

The grpcurl automatically serializes the response to this request into JSON including the transcription segments and the detected language.

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.