Made in Vancouver, Canada by Picovoice
Rhino is Picovoice's Speech-to-Intent engine. It directly infers intent from spoken commands within a given context of interest, in real-time. For example, given a spoken command:
Can I have a small double-shot espresso?
Rhino infers that the user and emits the following inference result:
{
"isUnderstood": "true",
"intent": "orderBeverage",
"slots": {
"beverage": "espresso",
"size": "small",
"numberOfShots": "2"
}
}Rhino is:
- using deep neural networks trained in real-world environments.
- compact and computationally-efficient. It is perfect for IoT.
- cross-platform: Raspberry Pi, BeagleBone, Android, iOS, Linux (x86_64), Mac (x86_64), Windows (x86_64), and web browsers are supported. Additionally, enterprise customers have access to the ARM Cortex-M SDK.
- self-service. Developers can train custom models using Picovoice Console.
- Rhino
The Rhino SDK is free and licensed under Apache 2.0, including the pre-trained models available within the repository. Picovoice Console offers two types of subscriptions: Personal and Enterprise. Personal accounts can train custom wake word models, subject to limitations and strictly for non-commercial purposes. Personal accounts empower researchers, hobbyists, and tinkerers to experiment. Enterprise accounts can unlock all capabilities of Picovoice Console, are permitted for use in commercial settings, and have a path to graduate to commercial distribution*.
Rhino is the right choice if the domain of voice interactions is specific (limited).
- If you want to create voice experiences similar to Alexa or Google, see the Picovoice platform.
- If you need to recognize a few static (always listening) voice commands, see Porcupine.
-
Rhino and Porcupine on an ARM Cortex-M7
- English, German, French and Spanish.
- Support for additional languages is available for commercial customers on a case-by-case basis.
A comparison between the accuracy of Rhino and major cloud-based alternatives is provided here. Below is the summary of the benchmark:
Rhino infers the user's intent from spoken commands within a domain of interest. We refer to such a specialized domain as
a Context. A context can be thought of a set of voice commands, each mapped to an intent:
turnLightOff:
- Turn off the lights in the office
- Turn off all lights
setLightColor:
- Set the kitchen lights to blueIn examples above, each voice command is called an Expression. Expressions are what we expect the user to utter
to interact with our voice application.
Consider the expression:
Turn off the lights in the office
What we require from Rhino is:
- To infer the intent (
turnLightOff) - Record the specific details from the utterance, in this case the location (
office)
We can capture these details using slots by updating the expression:
turnLightOff:
- Turn off the lights in the $location:lightLocation.$location:lightLocation means that we expect a variable of type location to occur and we want to capture its value
in a variable named lightLocation. We call such variable a Slot. Slots give us the ability to capture details of the
spoken commands. Each slot type is be defined as a set of phrases. For example:
lightLocation:
- "attic"
- "balcony"
- "basement"
- "bathroom"
- "bedroom"
- "entrance"
- "kitchen"
- "living room"
- ...You can create custom contexts using the Picovoice Console.
To learn the complete expression syntax of Rhino, see the Speech-to-Intent Syntax Cheat Sheet.
Install PyAudio and then the demo package:
sudo pip3 install pvrhinodemoWith a working microphone connected to your device run the following in the terminal:
rhino_demo_mic --context_path ${CONTEXT_FILE_PATH}
Replace ${CONTEXT_FILE_PATH} with either a context file created using Picovoice Console or one within the repository.
For more information about Python demos, go to demo/python.
Rhino .NET demo is a command-line application that lets you choose between running Rhino on an audio file or on real-time microphone input.
Make sure there is a working microphone connected to your device. From demo/dotnet/RhinoDemo run the following in the terminal:
dotnet run -c MicDemo.Release -- --context_path ${CONTEXT_FILE_PATH}Replace ${CONTEXT_FILE_PATH} with either a context file created using Picovoice Console or one within the repository.
For more information about .NET demos, go to demo/dotnet.
The Rhino Java demo is a command-line application that lets you choose between running Rhino on a audio file or on real-time microphone input.
To try the real-time demo, make sure there is a working microphone connected to your device. From the root of the repository run the following command:
java -jar demo/java/bin/rhino-mic-demo.jar -c ${CONTEXT_FILE_PATH}Replace ${CONTEXT_FILE_PATH} with either a context file created using Picovoice Console or one within the repository.
For more information about Java demos go to demo/java.
To run the Rhino Unity demo, import the Rhino Unity package into your project, open the RhinoDemo scene and hit play. To run on other platforms or in the player, go to File > Build Settings, choose your platform and hit the Build and Run button.
To browse the demo source go to demo/unity.
To run the Rhino demo on Android or iOS with Flutter, you must have the Flutter SDK installed on your system. Once installed, you can run flutter doctor to determine any other missing requirements for your relevant platform. Once your environment has been set up, launch a simulator or connect an Android/iOS device.
Before launching the app, use the copy_assets.sh script to copy the rhino demo context file into the demo project. (NOTE: on Windows, Git Bash or another bash shell is required, or you will have to manually copy the context into the project.).
Run the following command from demo/flutter to build and deploy the demo to your device:
flutter runThe demo uses a smart lighting context, which can understand commands such as:
Turn off the lights.
or
Set the lights in the living room to purple.
To run the React Native Rhino demo app you will first need to setup your React Native environment. For this, please refer to React Native's documentation. Once your environment has been set up, navigate to demo/react-native to run the following commands:
For Android:
yarn android-install # sets up environment
yarn android-run # builds and deploys to AndroidFor iOS:
yarn ios-install # sets up environment
yarn ios-run # builds and deploys to iOSBoth demos use a smart lighting context, which can understand commands such as:
Turn off the lights.
or
Set the lights in the living room to purple.
Using Android Studio, open demo/android/Activity as an Android project and then run the application. After pressing the start button you can issue commands such as:
Turn off the lights.
or:
Set the lights in the living room to purple.
For more information about Android demo and the complete list of available expressions, go to demo/android.
Before building the demo app, run the following from this directory to install the Rhino-iOS Cocoapod:
pod installThen, using Xcode, open the generated RhinoDemo.xcworkspace and run the application. After pressing
the start button you can issue commands such as:
Turn off the lights.
or:
Set the lights in the living room to purple.
For more information about Android demo and the complete list of available expressions go to demo/ios.
From demo/web run the following in the terminal:
yarn
yarn start(or)
npm install
npm run startOpen http://localhost:5000 in your browser to try the demo.
From demo/angular run the following in the terminal:
yarn
yarn start(or)
npm install
npm run startOpen http://localhost:4200 in your browser to try the demo.
From demo/react run the following in the terminal:
yarn
yarn start(or)
npm install
npm run startOpen http://localhost:3000 in your browser to try the demo.
From demo/vue run the following in the terminal:
yarn
yarn serve(or)
npm install
npm run serveOpen http://localhost:8080 in your browser to try the demo.
Install the node-record-lpcm16 NPM package, and follow the instructions there for setting up your microphone. Then install the demo package:
yarn global add @picovoice/rhino-node-demoWith a working microphone connected to your device, run the following in the terminal:
rhn-mic-demo --context_path ${CONTEXT_FILE_PATH}Replace ${CONTEXT_FILE_PATH} with either a context file created using Picovoice Console or one within the repository.
For more information about NodeJS demos go to demo/nodejs.
The Microphone demo runs on Linux-based systems (e.g. Ubuntu, Raspberry Pi, and BeagleBone).
Build the demo:
gcc -std=c99 -O3 -o demo/c/rhino_demo_mic -I include demo/c/rhino_demo_mic.c -ldl -lasoundFind the name of audio input device (microphone) on your computer using arecord -L and then from the root of the
repository run the demo:
./demo/c/rhino_demo_mic \
${RHINO_LIBRARY_PATH} \
lib/common/rhino_params.pv \
resources/contexts/${SYSTEM}/smart_lighting_${SYSTEM}.rhn \
${INPUT_AUDIO_DEVICE}Replace ${RHINO_LIBRARY_PATH} with path to appropriate library available under lib, ${SYSTEM} with the
name of the platform you are running on (linux, raspberry-pi, or beaglebone), and ${INPUT_AUDIO_DEVICE} with
the name of your microphone device. The demo opens an audio stream and your intent from spoken commands in the context
of a smart lighting system. For example you can say:
Turn on the lights in the bedroom.
Install the Python SDK:
pip3 install pvrhinoThe SDK exposes a factory method to create instances of the engine:
import pvrhino
handle = pvrhino.create(context_path='/absolute/path/to/context')Where context_path is the absolute path to the Speech-to-Intent context created either using Picovoice Console or one of
the default contexts available on Rhino's GitHub repository.
When initialized, the required sample rate can be obtained using rhino.sample_rate. The expected frame length
(number of audio samples in an input array) is provided by rhino.frame_length. The object can be used to infer intent from spoken
commands as below:
import pvrhino
handle = pvrhino.create(context_path='/absolute/path/to/context')
def get_next_audio_frame():
pass
while True:
is_finalized = handle.process(get_next_audio_frame())
if is_finalized:
inference = handle.get_inference()
if not inference.is_understood:
# add code to handle unsupported commands
pass
else:
intent = inference.intent
slots = inference.slots
# add code to take action based on inferred intent and slot valuesFinally, when done be sure to explicitly release the resources using handle.delete().
Install the .NET SDK using NuGet or the dotnet CLI:
dotnet add package RhinoThe SDK exposes a factory method to create instances of the engine as below:
using Pv
Rhino handle = Rhino.Create(contextPath:"/absolute/path/to/context");When initialized, the valid sample rate is given by handle.SampleRate. The expected frame length (number of audio samples
in an input array) is handle.FrameLength. The engine accepts 16-bit linearly-encoded PCM and operates on
single-channel audio.
short[] GetNextAudioFrame()
{
// .. get audioFrame
return audioFrame;
}
while(true)
{
bool isFinalized = handle.Process(GetNextAudioFrame());
if(isFinalized)
{
Inference inference = handle.GetInference();
if(inference.IsUnderstood)
{
string intent = inference.Intent;
Dictionary<string, string> slots = inference.Slots;
// .. code to take action based on inferred intent and slot values
}
else
{
// .. code to handle unsupported commands
}
}
}Rhino will have its resources freed by the garbage collector, but to have resources freed
immediately after use, wrap it in a using statement:
using(Rhino handle = Rhino.Create(contextPath:"/absolute/path/to/context"))
{
// .. Rhino usage here
}You can install the Rhino Java SDK by downloading and referencing the latest Rhino JAR file.
The SDK exposes a Builder that allows you to create an instance of the engine:
import ai.picovoice.rhino.*;
try{
Rhino handle = new Rhino.Builder()
.setContextPath("/absolute/path/to/context")
.build();
} catch (RhinoException e) { }When initialized, the valid sample rate is given by handle.getSampleRate(). The expected frame length (number of audio samples
in an input array) is handle.getFrameLength(). The engine accepts 16-bit linearly-encoded PCM and operates on
single-channel audio.
short[] getNextAudioFrame(){
// .. get audioFrame
return audioFrame;
}
while(true) {
boolean isFinalized = handle.process(getNextAudioFrame());
if(isFinalized){
RhinoInference inference = handle.getInference();
if(inference.getIsUnderstood()){
String intent = inference.getIntent();
Map<string, string> slots = inference.getSlots();
// .. code to take action based on inferred intent and slot values
} else {
// .. code to handle unsupported commands
}
}
}Once you are done with Rhino, ensure you release its resources explicitly:
handle.delete();Import the Rhino Unity Package into your Unity project.
The SDK provides two APIs:
RhinoManager provides a high-level API that takes care of audio recording. This class is the quickest way to get started.
Using the constructor RhinoManager.Create will create an instance of the RhinoManager using the provided context file.
using Pv.Unity;
try
{
RhinoManager _rhinoManager = RhinoManager.Create(
"/path/to/context/file.rhn",
(inference) => {});
}
catch (Exception ex)
{
// handle rhino init error
}Once you have instantiated a RhinoManager, you can start audio capture and intent inference by calling:
_rhinoManager.Process();Audio capture stops and Rhino resets once an inference result is returned via the inference callback. When you wish to result, call .Process() again.
Once the app is done with using an instance of RhinoManager, you can explicitly release the audio resources and the resources allocated to Rhino:
_rhinoManager.Delete();There is no need to deal with audio capture to enable intent inference with RhinoManager. This is because it uses our unity-voice-processor Unity package to capture frames of audio and automatically pass it to the inference engine.
Rhino provides low-level access to the inference engine for those who want to incorporate speech-to-intent into a already existing audio processing pipeline.
To create an instance of Rhino, use the .Create static constructor and a context file.
using Pv.Unity;
try
{
Rhino _rhino = Rhino.Create("path/to/context/file.rhn");
}
catch (Exception ex)
{
// handle rhino init error
}To feed Rhino your audio, you must send it frames of audio to its Process function until it has made an inference.
short[] GetNextAudioFrame()
{
// .. get audioFrame
return audioFrame;
}
try
{
bool isFinalized = _rhino.Process(GetNextAudioFrame());
if(isFinalized)
{
Inference inference = _rhino.GetInference();
if(inference.IsUnderstood)
{
string intent = inference.Intent;
Dictionary<string, string> slots = inference.Slots;
// .. code to take action based on inferred intent and slot values
}
else
{
// .. code to handle unsupported commands
}
}
}
catch (Exception ex)
{
Debug.LogError(ex.ToString());
}For process to work correctly, the audio data must be in the audio format required by Picovoice.
Rhino implements the IDisposable interface, so you can use Rhino in a using block. If you don't use a using block, resources will be released by the garbage collector automatically or you can explicitly release the resources like so:
_rhino.Dispose();Add the Rhino Flutter plugin to your pub.yaml.
dependencies:
rhino: ^<version>The SDK provides two APIs:
RhinoManager provides a high-level API that takes care of audio recording. This class is the quickest way to get started.
The constructor RhinoManager.create will create an instance of the RhinoManager using a context file that you pass to it.
import 'package:rhino/rhino_manager.dart';
import 'package:rhino/rhino_error.dart';
void createRhinoManager() async {
try{
_rhinoManager = await RhinoManager.create(
"/path/to/context/file.rhn",
_inferenceCallback);
} on PvError catch (err) {
// handle rhino init error
}
}The inferenceCallback parameter is a function that you want to execute when Rhino makes an inference.
The function should accept a map that represents the inference result.
void _infererence(Map<String, dynamic> inference){
if(inference['isUnderstood']){
String intent = inference['intent']
Map<String, String> = inference['slots']
// add code to take action based on inferred intent and slot values
}
else{
// add code to handle unsupported commands
}
}Once you have instantiated a RhinoManager, you can start audio capture and intent inference using the .process() function.
Audio capture stops and rhino resets once an inference result is returned via the inference callback.
try{
await _rhinoManager.process();
} on PvAudioException catch (ex) { }Once your app is done with using RhinoManager, be sure you explicitly release the resources allocated for it:
_rhinoManager.delete();Our flutter_voice_processor Flutter plugin captures the frames of audio and automatically passes it to the speech-to-intent engine.
Rhino provides low-level access to the inference engine for those who want to incorporate speech-to-intent into a already existing audio processing pipeline.
Rhino is created by passing a context file to its static constructor create:
import 'package:rhino/rhino_manager.dart';
import 'package:rhino/rhino_error.dart';
void createRhino() async {
try{
_rhino = await Rhino.create('/path/to/context/file.rhn');
} on PvError catch (err) {
// handle rhino init error
}
}To deliver audio to the engine, you must send audio frames to its process function.
Each call to process will return a Map object that will contain the following items:
- isFinalized - whether Rhino has made an inference
- isUnderstood - if isFinalized, whether Rhino understood what it heard based on the context
- intent - if isUnderstood, name of intent that were inferred
- slots - if isUnderstood, dictionary of slot keys and values that were inferred
List<int> buffer = getAudioFrame();
try {
Map<String, dynamic> inference = _rhino.process(buffer);
if(inference['isFinalized']){
if(inference['isUnderstood']){
String intent = inference['intent']
Map<String, String> = inference['slots']
// add code to take action based on inferred intent and slot values
}
}
} on PvError catch (error) {
// handle error
}
// once you are done
this._rhino.delete();Install @picovoice/react-native-voice-processor and @picovoice/rhino-react-native. The SDK provides two APIs:
RhinoManager provides a high-level API that takes care of audio recording. This class is the quickest way to get started.
The constructor RhinoManager.create will create an instance of a RhinoManager using a context file that you pass to it.
async createRhinoManager(){
try{
this._rhinoManager = await RhinoManager.create(
'/path/to/context/file.rhn',
inferenceCallback);
} catch (err) {
// handle error
}
}Once you have instantiated a RhinoManager, you can start/stop audio capture and intent inference by calling .process().
Upon receiving an inference callback, audio capture will stop automatically and Rhino will reset. To restart it you must
call .process() again.
let didStart = await this._rhinoManager.process();When you are done using Rhino, release you must explicitly resources:
this._rhinoManager.delete();@picovoice/react-native-voice-processor handles audio capture and RhinoManager passes frames to the inference engine for you.
Rhino provides low-level access to the inference engine for those who want to incorporate speech-to-intent into a already existing audio processing pipeline.
Rhino is created by passing a context file to its static constructor create:
async createRhino(){
try{
this._rhino = await Rhino.create('/path/to/context/file.rhn');
} catch (err) {
// handle error
}
}To deliver audio to the enine, you must pass it audio frames
using the process function. The JSON result that is returned from process will have up to four fields:
- isFinalized - whether Rhino has made an inference
- isUnderstood - if isFinalized, whether Rhino understood what it heard based on the context
- intent - if isUnderstood, name of intent that were inferred
- slots - if isUnderstood, dictionary of slot keys and values that were inferred
let buffer = getAudioFrame();
try {
let result = await this._rhino.process(buffer);
// use result
// ..
}
} catch (e) {
// handle error
}
// once you are done
this._rhino.delete();To include the package in your Android project, ensure you have included mavenCentral() in your top-level build.gradle file and then add the following to your app's build.gradle:
dependencies {
implementation 'ai.picovoice:rhino-android:1.6.0'
}There are two possibilities for integrating Rhino into an Android application: the High-level API and the Low-level API.
RhinoManager provides a high-level API for integrating Rhino into Android applications. It manages all activities related to creating an input audio stream, feeding it into Rhino, and invoking a user-provided inference callback.
try {
RhinoManager rhinoManager = new RhinoManager.Builder()
.setContextPath("/path/to/context/file.rhn")
.setModelPath("/path/to/model/file.pv")
.setSensitivity(0.35f)
.build(appContext, new RhinoManagerCallback() {
@Override
public void invoke(RhinoInference inference) {
if (inference.getIsUnderstood()) {
final String intent = inference.getIntent()));
final Map<String, String> slots = inference.getSlots();
// add code to take action based on inferred intent and slot values
}
else {
// add code to handle unsupported commands
}
}
});
} catch (RhinoException e) { }The appContext parameter is the Android application context - this is used to extract Rhino resources from the APK.
Sensitivity is the parameter that enables developers to trade miss rate for false alarm. It is a floating point number within
[0, 1]. A higher sensitivity reduces miss rate at cost of increased false alarm rate.
When initialized, input audio can be processed using manager.process(). When done, be sure to release the resources
using manager.delete().
Rhino provides a binding for Android using JNI. It can be initialized using:
import ai.picovoice.rhino.*;
try {
Rhino rhino = new Rhino.Builder()
.setContextPath("/path/to/context/file.rhn")
.build(appContext);
} catch (RhinoException e) { }Once initialized, handle can be used for intent inference:
private short[] getNextAudioFrame();
while (!handle.process(getNextAudioFrame()));
final RhinoInference inference = handle.getInference();
if (inference.getIsUnderstood()) {
// logic to perform an action given the intent object.
} else {
// logic for handling out of context or unrecognized command
}Finally, prior to exiting the application be sure to release resources acquired:
handle.delete()The Rhino iOS binding is available via Cocoapods. To import it into your iOS project, add the following line to your Podfile and run pod install:
pod 'Rhino-iOS'There are two approaches for integrating Rhino into an iOS application: The high-level API and the low-level API.
RhinoManager provides a high-level API for integrating Rhino into iOS applications. It manages all activities related to creating an input audio stream, feeding it to the engine, and invoking a user-provided inference callback.
do {
RhinoManager manager = try RhinoManager(
contextPath: "/path/to/context/file.rhn",
modelPath: "/path/to/model/file.pv",
sensitivity: 0.35,
onInferenceCallback: { inference in
if inference.isUnderstood {
let intent:String = inference.intent
let slots:Dictionary<String,String> = inference.slots
// use inference results
}
})
} catch { }Sensitivity is the parameter that enables developers to trade miss rate for false alarm. It is a floating point number within [0, 1]. A higher sensitivity reduces miss rate at cost of increased false alarm rate.
When initialized, input audio can be processed using manager.process(). When done, be sure to release the resources
using manager.delete().
Rhino provides low-level access to the Speech-to-Intent engine for those who want to incorporate intent inference into a already existing audio processing pipeline.
import Rhino
do {
Rhino handle = try Rhino(contextPath: "/path/to/context/file.rhn")
} catch { }Once initialized, handle can be used for intent inference:
func getNextAudioFrame() -> [Int16] {
// .. get audioFrame
return audioFrame
}
while true {
do {
let isFinalized = try handle.process(getNextAudioFrame())
if isFinalized {
let inference = try handle.getInference()
if inference.isUnderstood {
let intent:String = inference.intent
let slots:Dictionary<String, String> = inference.slots
// add code to take action based on inferred intent and slot values
}
}
} catch { }
}Finally, prior to exiting the application be sure to release resources acquired:
handle.delete()Rhino is available on modern web browsers (i.e. not Internet Explorer) via WebAssembly. Microphone audio is handled via the Web Audio API and is abstracted by the WebVoiceProcessor, which also handles downsampling to the correct format. Rhino is provided pre-packaged as a Web Worker.
Each spoken language is available as a dedicated npm package (e.g. @picovoice/rhino-web-en-worker). These packages can be used with the @picovoice/web-voice-processor. They can also be used with the Angular, React, and Vue bindings, which abstract and hide the web worker communication details.
<!DOCTYPE html>
<html lang="en">
<head>
<script src="https://unpkg.com/@picovoice/rhino-web-en-worker/dist/iife/index.js"></script>
<script src="https://unpkg.com/@picovoice/web-voice-processor/dist/iife/index.js"></script>
<script type="application/javascript">
const RHINO_CONTEXT_BASE64 = /* Base64 representation of .rhn file */;
async function startRhino() {
console.log("Rhino is loading. Please wait...");
window.rhinoWorker = await RhinoWebEnWorker.RhinoWorkerFactory.create(
{
context: {
base64: RHINO_CONTEXT_BASE64,
sensitivity: 0.5,
},
start: false,
}
);
console.log("Rhino worker ready!");
window.rhinoWorker.onmessage = (msg) => {
if (msg.data.command === "rhn-inference") {
console.log("Inference detected: " + JSON.stringify(msg.data.inference));
window.rhinoWorker.postMessage({ command: "pause" });
document.getElementById("push-to-talk").disabled = false;
console.log("Rhino is paused. Press the 'Push to Talk' button to speak again.")
}
};
console.log(
"WebVoiceProcessor initializing. Microphone permissions requested ..."
);
try {
let webVp = await WebVoiceProcessor.WebVoiceProcessor.init({
engines: [window.rhinoWorker],
});
console.log(
"WebVoiceProcessor ready! Press the 'Push to Talk' button to talk."
);
} catch (e) {
console.log("WebVoiceProcessor failed to initialize: " + e);
}
}
document.addEventListener("DOMContentLoaded", function () {
startRhino();
document.getElementById("push-to-talk").onclick = function (event) {
console.log("Rhino is listening for your commands ...");
this.disabled = true;
window.rhinoWorker.postMessage({ command: "resume" });
};
});
</script>
</head>
<body>
<button id="push-to-talk">Push to Talk</button>
</body>
</html>yarn add @picovoice/rhino-web-en-worker @picovoice/web-voice-processor(or)
npm install @picovoice/rhino-web-en-worker @picovoice/web-voice-processorimport { WebVoiceProcessor } from "@picovoice/web-voice-processor"
import { RhinoWorkerFactory } from "@picovoice/rhino-web-en-worker";
const RHN_CONTEXT_BASE64 = /* Base64 representation of a .rhn context */
async startRhino()
// Create a Rhino Worker (English language) to listen for
// commands in the specified context
const rhinoWorker = await RhinoWorkerFactory.create(
{context: RHN_CONTEXT_BASE64 }
);
// The worker will send a message with data.command = "rhn-inference" upon concluding
// Here we tell it to log it to the console
rhinoWorker.onmessage = (msg) => {
switch (msg.data.command) {
case 'rhn-inference':
// Log the event
console.log("Rhino inference: " + msg.data.inference);
// Pause Rhino processing until the push-to-talk button is pressed again
rhinoWorker.postMessage({command: "pause"})
break;
default:
break;
}
};
// Start up the web voice processor. It will request microphone permission
// It downsamples the audio to voice recognition standard format (16-bit 16kHz linear PCM, single-channel)
// The incoming microphone audio frames will then be forwarded to the Rhino Worker
// n.b. This promise will reject if the user refuses permission! Make sure you handle that possibility.
const webVp = await WebVoiceProcessor.init({
engines: [rhinoWorker],
start: true,
});
}
// Rhino is push-to-talk. We need to to tell it that we
// are starting a voice interaction:
function pushToTalk() {
rhinoWorker.postMessage({command: "resume"})
}
}
startRhino()
...
// Finished with Rhino? Release the WebVoiceProcessor and the worker.
if (done) {
webVp.release()
rhinoWorker.sendMessage({command: "release"})
}yarn add @picovoice/rhino-web-angular @picovoice/rhino-web-en-worker(or)
npm install @picovoice/rhino-web-angular @picovoice/rhino-web-en-workerasync ngOnInit() {
const rhinoFactoryEn = (await import('@picovoice/rhino-web-en-worker')).RhinoWorkerFactory
// Initialize Rhino Service
try {
await this.rhinoService.init(rhinoFactoryEn, {context: { base64: RHN_CONTEXT_BASE64 }})
console.log("Rhino is now loaded. Press the Push-to-Talk button to activate.")
}
catch (error) {
console.error(error)
}
}
ngOnDestroy() {
this.rhinoDetection.unsubscribe()
this.rhinoService.release()
}
public pushToTalk() {
this.rhinoService.pushToTalk();
}yarn add @picovoice/rhino-web-react @picovoice/rhino-web-en-worker(or)
npm install @picovoice/rhino-web-react @picovoice/rhino-web-en-workermport React, { useState } from 'react';
import { RhinoWorkerFactory } from '@picovoice/rhino-web-en-worker';
import { useRhino } from '@picovoice/rhino-web-react';
const RHINO_CONTEXT_BASE64 = /* Base64 representation an English language .rhn file, omitted for brevity */
function VoiceWidget(props) {
const [latestInference, setLatestInference] = useState(null)
const inferenceEventHandler = (rhinoInference) => {
console.log(`Rhino inferred: ${rhinoInference}`);
setLatestInference(rhinoInference)
};
const {
isLoaded,
isListening,
isError,
isTalking,
errorMessage,
start,
resume,
pause,
pushToTalk,
} = useRhino(
// Pass in the factory to build Rhino workers. This needs to match the context language below
RhinoWorkerFactory,
// Initialize Rhino (in a paused state).
// Immediately start processing microphone audio,
// Although Rhino itself will not start listening until the Push to Talk button is pressed.
{
context: { base64: RHINO_CONTEXT_BASE64 },
start: true,
}
inferenceEventHandler
);
return (
<div className="voice-widget">
<button onClick={() => pushToTalk()} disabled={isTalking || isError || !isLoaded}>
Push to Talk
</button>
<p>{JSON.stringify(latestInference)}</p>
</div>
)yarn add @picovoice/rhino-web-vue @picovoice/rhino-web-en-worker(or)
npm install @picovoice/rhino-web-vue @picovoice/rhino-web-en-worker<template>
<div class="voice-widget">
<Rhino
ref="rhino"
v-bind:rhinoFactoryArgs="{
context: {
base64: '...', <!-- Base64 representation of a trained Rhino context; i.e. a `.rhn` file, omitted for brevity -->
},
}"
v-bind:rhinoFactory="factory"
v-on:rhn-error="rhnErrorFn"
v-on:rhn-inference="rhnInferenceFn"
v-on:rhn-init="rhnInitFn"
v-on:rhn-ready="rhnReadyFn"
/>
</div>
</template>
<script>
import Rhino from "@picovoice/rhino-web-vue";
import { RhinoWorkerFactory as RhinoWorkerFactoryEn } from "@picovoice/rhino-web-en-worker";
export default {
name: "VoiceWidget",
components: {
Rhino,
},
data: function () {
return {
inference: null,
isError: false,
isLoaded: false,
isListening: false,
isTalking: false,
factory: RhinoWorkerFactoryEn,
};
},
methods: {
pushToTalk: function () {
if (this.$refs.rhino.pushToTalk()) {
this.isTalking = true;
}
},
rhnInitFn: function () {
this.isError = false;
},
rhnReadyFn: function () {
this.isLoaded = true;
this.isListening = true;
},
rhnInferenceFn: function (inference) {
this.inference = inference;
console.log("Rhino inference: " + inference)
this.isTalking = false;
},
rhnErrorFn: function (error) {
this.isError = true;
this.errorMessage = error.toString();
},
},
};Install the NodeJS SDK:
yarn add @picovoice/rhino-nodeCreate instances of the Rhino class by specifying the path to the context file:
const Rhino = require("@picovoice/rhino-node");
let handle = new Rhino("/path/to/context/file.rhn");When instantiated, handle can process audio via its .process method:
let getNextAudioFrame = function() {
...
};
let isFinalized = false;
while (!isFinalized) {
isFinalized = handle.process(getNextAudioFrame());
if (isFinalized) {
let inference = engineInstance.getInference();
// Insert inference event callback
}
}When done, be sure to release resources acquired by WebAssembly using release():
handle.release();Rhino is implemented in ANSI C and therefore can be directly linked to C applications. The pv_rhino.h header file contains relevant information. An instance of the Rhino object can be constructed as follows:
const char *model_path = ... // Available at lib/common/rhino_params.pv
const char *context_path = ... // absolute path to context file for the domain of interest
const float sensitivity = 0.5f;
pv_rhino_t *handle = NULL;
const pv_status_t status = pv_rhino_init(model_path, context_path, sensitivity, &handle);
if (status != PV_STATUS_SUCCESS) {
// add error handling code
}Now the handle can be used to infer intent from an incoming audio stream. Rhino accepts single channel, 16-bit PCM
audio. The sample rate can be retrieved using pv_sample_rate(). Finally, Rhino accepts input audio in consecutive chunks
(frames); the length of each frame can be retrieved using pv_rhino_frame_length().
extern const int16_t *get_next_audio_frame(void);
while (true) {
const int16_t *pcm = get_next_audio_frame();
bool is_finalized = false;
pv_status_t status = pv_rhino_process(handle, pcm, &is_finalized);
if (status != PV_STATUS_SUCCESS) {
// add error handling code
}
if (is_finalized) {
bool is_understood = false;
status = pv_rhino_is_understood(rhino, &is_understood);
if (status != PV_STATUS_SUCCESS) {
// add error handling code
}
if (is_understood) {
const char *intent = NULL;
int32_t num_slots = 0;
const char **slots = NULL;
const char **values = NULL;
status = pv_rhino_get_intent(rhino, &intent, &num_slots, &slots, &values);
if (status != PV_STATUS_SUCCESS) {
// add error handling code
}
// add code to take action based on inferred intent and slot values
pv_rhino_free_slots_and_values(rhino, slots, values);
} else {
// add code to handle unsupported commands
}
pv_rhino_reset(rhino);
}
}When done, remember to release the resources acquired.
pv_rhino_delete(rhino);- Added support for React Native.
- Added support for Java.
- Added support for .NET.
- Added support for NodeJS.
- Accuracy improvements.
- Accuracy improvements.
- Builtin slots
- Accuracy improvements.
- Runtime optimizations.
- Added support for Raspberry Pi 4
- Added support for JavaScript.
- Added support for iOS.
- Updated documentation.
- Accuracy improvements.
- Runtime optimizations.
- Accuracy improvements.
- Open-sourced Raspberry Pi build.
- Initial Release
You can find the FAQ here.