Pronunciation assessment that runs on your own servers.

Give it a recording. It returns the scores trained raters would give and the words that went wrong, whether or not you know the sentence the speaker meant to say.

$ pip install openpronounce

Accuracy
Fluency
Prosody
from openpronounce import load_audio, assess

result = assess(load_audio("developer.wav"), "Hello, I am a good designer")
result["score"]       # 36.2
result["reasons"]     # ['not said: good']
Two recordings from the project’s repository. Run this code on them and you get these numbers.

The recordings stay on your servers. Nobody charges you by the minute.

No recording leaves your machines

A voice recording is personal data. Sent to a cloud API, each one goes to a vendor: one more processor in your privacy policy, a contract to sign, sometimes a transfer outside the European Union. OpenPronounce runs on an ordinary CPU server (a two-second sentence takes 0.45 s in quick mode on 16 threads, models loaded) and works offline once the speech models are downloaded.

No meter

Cloud APIs charge by the minute or by the request. OpenPronounce is free under the AGPL, and a closed product pays a yearly licence with no volume limit. You still pay for the servers it runs on.

Numbers you can check

The agreement with human raters is published with the scripts that reproduce it. One command measures it again on recordings your own assessors have scored, before you show a single score to a user.

One default to know about: the first time a sentence is analysed, its text (never the audio) goes to Google's speech synthesis to build a reference reading. One setting turns it off.

Or let it run on the speaker’s own device.

For English read aloud, OpenPronounce also fits in a web page. The recording is marked on the phone or laptop that made it: no audio server to run, nothing uploaded, and it keeps working offline once loaded.

The small model was distilled from the large one, and it agrees with expert raters just as well: on the speechocean762 test recordings it finds the mispronounced words with an AUC of 0.939, against 0.928 for the original. In your own app, it runs under the AGPL like the rest, or under the commercial licence in a closed product.

Agreement with human raters

The English models were trained and tested on speechocean762: 5,000 recordings of non-native speakers, each rated by five experts. The bars give the Pearson correlation between the overall score and the raters' average on the 2,500 test recordings, whose speakers were kept out of training.

At word level it flags about one word in twenty, and the raters had marked a little more than half of those.

It judges pronunciation only. French, Spanish, German, Italian, Portuguese and Dutch run on the same models, but English is the only language measured against raters, and children speaking freely are scored poorly. Every known limit, with its figure.

Sentence knownFree speech
Adults1,220 recordings
0.85
0.82
All speakers2,500 recordings
0.79
0.71
Children, 12 and under1,040 recordings
0.67
0.42

One call, one JSON document

Pass the sentence when the speaker reads one, and OpenPronounce aligns each expected sound on the recording to say which word went wrong and how. Leave it out for an open answer or a talk: the recording is transcribed, cut at its pauses, and each part is scored.

Four scores
Overall, accuracy, fluency and prosody, from 0 to 100, on the scale of five expert raters.
The words to work on
Sounds expected and sounds heard, in IPA, with their timing. Skipped words and extra speech are listed apart: in the benchmark, 83 skipped words in 100 are caught.
reliable
False when the recording does not match the sentence, words are missing, there is too little speech, or the audio is poor. The reasons come in plain text.
The transcript
Word by word, with timings.
from openpronounce import load_audio, assess

# the speaker read a known sentence
audio = load_audio("developer.wav")
result = assess(audio, "Hello, I am a good designer")
result["score"]       # 36.2
result["reliable"]    # False

# free speech: no sentence, any length
talk = assess(load_audio("talk.wav"))
talk["segments"]      # one entry per part, with its scores

Your speakers will differ from the benchmark. openpronounce-evaluate computes the same correlation on recordings your assessors have scored, with a confidence interval. Here on 150 test recordings. How to run it on your data.

$ openpronounce-evaluate recordings.csv
150 recordings: 150 compared with a rating
flagged unreliable: 1, poor recording quality: 0
all  n=150  Pearson 0.840 [0.78, 0.88]
to read our score on your scale: yours = 0.1001 x ours + 0.031

The questions it answers

Nobody wants a pronunciation score for its own sake. Behind each request there is a question.

“Will customers understand this candidate on the phone?”

Hiring for a call centre

Each candidate answers one question over the phone. The recruiter listens first to those near the threshold, set from candidates the team has already judged on the same phone line.

90 seconds of free speech

“Will my new colleagues understand me?”

Joining a team abroad

Read the sentences of a real working day. Each flagged word comes back with the sounds expected, the sounds heard, and the moment to replay.

the sentences of a real day

“Will the room follow my talk?”

Before a presentation

Record the whole rehearsal. OpenPronounce cuts it at the pauses and scores each part, so you know which parts to rehearse again.

a rehearsal, cut at its pauses

“Am I getting better?”

Following progress

Record the same sentences every week and compare averages, never one take with another: a single score carries a few points of noise.

same sentences, every week

Free under the AGPL. From 1,200 € a year for a closed product.

The code, the models and the scripts that trained them are published under the AGPL-3.0. Research, evaluation and open-source products use them free of charge. A product whose code stays closed takes a yearly licence, priced by the size of the company, with no volume limit. Nothing is held back: what companies pay for is the version anyone can read.

The licences fund maintenance and new languages. How the project is run.

Jean-François Lépine

“I wanted a pronunciation engine I could read, measure and run on my own machines. It did not exist, so I built it in the open.”

Jean-François Lépine, maintainer. Thirty years of software, author of PhpMetrics and AST Metrics. How the project is run.

Useful to you? Star it.

A star costs one click and shows the maintainers that the project is used. If a score looks wrong, a sound is misheard or your language is missing, open an issue.