How to Install & Test the Python SpeechRecognition Module With Examples

In the ever-evolving landscape of technology, voice recognition has become an integral part of various applications, from virtual assistants to transcription services. Python, a versatile and powerful programming language, offers a convenient module called SpeechRecognition that facilitates seamless integration of speech-to-text functionality into your projects. In this article, we will walk you through the step-by-step process of installing the SpeechRecognition module and provide practical examples to kickstart your journey into the realm of voice-enabled applications.

Table of Contents

1. Installing SpeechRecognition.

Before delving into the installation process, it’s crucial to ensure that you have Python and pip installed on your system.

Once that’s confirmed, open your command prompt or terminal and enter the command pip install SpeechRecognition.

This command fetches the SpeechRecognition module from the Python Package Index (PyPI) and installs it on your machine. Make sure your internet connection is stable to download the necessary files.

(MyPython) PS C:\Users\Zhao Song> pip install SpeechRecognition
Defaulting to user installation because normal site-packages is not writeable
Collecting SpeechRecognition
  Using cached SpeechRecognition-3.10.1-py2.py3-none-any.whl.metadata (28 kB)
Requirement already satisfied: requests>=2.26.0 in c:\users\zhao song\appdata\roaming\python\python39\site-packages (from SpeechRecognition) (2.28.2)
Collecting typing-extensions (from SpeechRecognition)
  Using cached typing_extensions-4.9.0-py3-none-any.whl.metadata (3.0 kB)
Requirement already satisfied: charset-normalizer<4,>=2 in c:\users\zhao song\appdata\roaming\python\python39\site-packages (from requests>=2.26.0->SpeechRecognition) (3.0.1)
Requirement already satisfied: idna<4,>=2.5 in c:\users\zhao song\appdata\roaming\python\python39\site-packages (from requests>=2.26.0->SpeechRecognition) (3.4)
Requirement already satisfied: urllib3<1.27,>=1.21.1 in c:\users\zhao song\appdata\roaming\python\python39\site-packages (from requests>=2.26.0->SpeechRecognition) (1.26.12)
Requirement already satisfied: certifi>=2017.4.17 in c:\programdata\anaconda3\envs\mypython\lib\site-packages (from requests>=2.26.0->SpeechRecognition) (2022.6.15)
Downloading SpeechRecognition-3.10.1-py2.py3-none-any.whl (32.8 MB)
   ---------------------------------------- 32.8/32.8 MB 77.1 kB/s eta 0:00:00
Downloading typing_extensions-4.9.0-py3-none-any.whl (32 kB)
Installing collected packages: typing-extensions, SpeechRecognition
Successfully installed SpeechRecognition-3.10.1 typing-extensions-4.9.0

2. Installing Additional Dependencies.

SpeechRecognition relies on various external speech recognition engines, such as Google Web Speech API, Sphinx, and others.

To use these engines, you need to install additional dependencies. For instance, to use the Google Web Speech API, you can install the `pyaudio` library by running the command pip install pyaudio.

Note that installing `pyaudio` might require additional setup, especially on systems like Linux. Refer to the official documentation for platform-specific instructions.

(MyPython) PS C:\Users\Zhao Song> pip install pyaudio
Defaulting to user installation because normal site-packages is not writeable
Collecting pyaudio
  Downloading PyAudio-0.2.14-cp39-cp39-win_amd64.whl.metadata (2.7 kB)
Downloading PyAudio-0.2.14-cp39-cp39-win_amd64.whl (164 kB)
   ---------------------------------------- 164.1/164.1 kB 30.5 kB/s eta 0:00:00
Installing collected packages: pyaudio
Successfully installed pyaudio-0.2.14

Besides the pyaudio module, it also need to install the PocketSphinx module to use the recognize_sphinx function in the SpeechRecognition module, when you can not use the

recognize_google fucntion to parse the audio to text, this is an alternative method.

Here are the steps to install the PocketSphinx module. Open a terminal and run the command pip install PocketSphinx.

(MyPython) PS C:\Users\Zhao Song> pip install PocketSphinx
Defaulting to user installation because normal site-packages is not writeable
Collecting PocketSphinx
  Downloading pocketsphinx-5.0.2.tar.gz (34.2 MB)
     ---------------------------------------- 34.2/34.2 MB 20.5 kB/s eta 0:00:00
  Installing build dependencies ... \

If you can not successfully install the Python PocketSphinx module, you can read the article How to Fix ERROR: Failed building wheel for PocketSphinx to learn how to fix it.

3. Python speech_recognition Module Introdution.

The `speech_recognition` module in Python provides a convenient way to work with speech recognition APIs.

The `Recognizer` class is a key component of this module, and it has several functions, including `adjust_for_ambient_noise`, `recognize_google`, and `recognize_sphinx`. Let’s take a closer look at each of them:

3.1 `adjust_for_ambient_noise` function.

This function is used to adjust the recognizer’s sensitivity to ambient noise.
It takes an audio source as an argument and listens to the ambient noise for a brief period to determine the noise level.

After determining the noise level, it adjusts the recognizer’s sensitivity accordingly, making it more suitable for recognizing speech in the given environment.

import speech_recognition as sr

def adjust_env_noise_level():
    recognizer = sr.Recognizer()

    with sr.Microphone() as source:
        print("Adjusting for ambient noise...")
        recognizer.adjust_for_ambient_noise(source)
        print("Ambient noise adjusted. You can start speaking now.")

if __name__ == "__main__":
    adjust_env_noise_level()

Output.

Adjusting for ambient noise...
Ambient noise adjusted. You can start speaking now.

3.2 `recognize_google` function.

This function uses the Google Web Speech API to perform speech recognition.

It takes an audio source as input and returns the recognized speech as a string.
Note that to use this function, you need an internet connection as it relies on the Google Web Speech API.

3.3 `recognize_sphinx` function.

This function uses the Sphinx recognizer, which is an offline speech recognition system.

It does not require an internet connection, making it suitable for certain use cases where an internet connection might not be available.
However, Sphinx may have limitations compared to cloud-based solutions like Google’s.

4. Testing SpeechRecognition with a Basic Example.

Now that you have successfully installed the SpeechRecognition module and its dependencies, let’s test it with a simple example.

Create a Python script (e.g., `speech_recognition_example.py`) and use the following code:
Be attention to the code line recognizer.adjust_for_ambient_noise(source), if you omit this line, your code will hang at the line audio = recognizer.listen(source).

Full source code.

import speech_recognition as sr

def recognize_speech():
    # Create a recognizer instance
    recognizer = sr.Recognizer()

    # Capture audio from the microphone
    with sr.Microphone() as source:
        print("Say something:")
        try:
            # If you comment the below source code, the program will hang at this line.
            recognizer.adjust_for_ambient_noise(source)
            audio = recognizer.listen(source)
        except sr.UnknownValueError:
            print("Could not understand audio")
        except sr.RequestError as e:
            print(f"Error connecting to Google Web Speech API: {e}")
        finally:
            print('Speech complete.')

    try:
        # Recognize speech using Google Web Speech API
        text = recognizer.recognize_google(audio)
        #text = recognizer.recognize_sphinx(audio)

        print(f"You said: {text}")
    except sr.UnknownValueError:
        print("Could not understand audio")
    except sr.RequestError as e:
        print(f"Error connecting to Google Web Speech API: {e}")

if __name__ == "__main__":
    recognize_speech()

This example utilizes the Google Web Speech API to convert spoken words into text. Run the script, speak into your microphone, and watch as the program prints the transcribed text to the console.

5. Exploring Advanced Features.

SpeechRecognition provides various advanced features to enhance your voice recognition applications.
For instance, you can recognize speech from audio files, work with different recognition engines, and customize recognition parameters. Let’s explore a few additional features:

5.1 Recognizing Speech from an Audio File.

Example source code.

import speech_recognition as sr

def recognizing_speech_from_an_audio_file(audio_file):

    recognizer = sr.Recognizer()

    # Load audio file
    with sr.AudioFile(audio_file) as source:
        audio = recognizer.record(source)

        try:
            recognizer.adjust_for_ambient_noise(source)
            #text = recognizer.recognize_google(audio)
            text = recognizer.recognize_sphinx(audio)
            print(f"Text from audio file: {text}")
        except sr.UnknownValueError:
            print("Could not understand audio")
        except sr.RequestError as e:
            print(f"Error connecting to Google Web Speech API: {e}")



if __name__ == "__main__":
    recognizing_speech_from_an_audio_file('Recording.wav')

6. Conclusion.

In this guide, we’ve walked you through the installation process of the SpeechRecognition module and provided practical examples to get you started with voice recognition in Python.
As technology continues to advance, integrating speech recognition into your applications opens up new possibilities for user interaction and accessibility.

Experiment with different engines, explore advanced features, and let your creativity drive the development of innovative voice-enabled projects. Happy coding!