Cheetah

由加拿大温哥华的 Picovoice 制作

Cheetah 是一个设备上的流式语音转文本引擎。Cheetah 具有以下特点：

隐私保护：所有语音处理在本地进行。
准确
体积小且计算效率高
跨平台：
- Linux (x86_64)、macOS (x86_64, arm64) 和 Windows (x86_64)
- Android 和 iOS
- Chrome、Safari、Firefox 和 Edge
- Raspberry Pi (3, 4, 5) 和 NVIDIA Jetson Nano

Cheetah
- 目录
- 访问密钥
- 语言支持
- 演示
  - Python
  - C
  - iOS
  - Android
  - Flutter
  - Go
  - React Native
  - Java
  - Node.js
  - .Net
  - Rust
  - Web
    - 原生 JavaScript 和 HTML
    - React
- SDK
  - Python
  - C
  - iOS
  - Android
  - Flutter
  - Go
  - React Native
  - Node.js
  - Java
  - .Net
  - Rust
  - Web
    - 原生 JavaScript 和 HTML（ES 模块）
    - React
- 发布

访问密钥

访问密钥是用于部署 Picovoice SDK（包括 Cheetah）的身份验证和授权令牌。任何使用 Picovoice 的人都需要有一个有效的访问密钥。您必须保密您的访问密钥。即使语音识别是 100% 离线运行的，您也需要互联网连接来验证您的访问密钥与 Picovoice 许可服务器。

访问密钥还验证您的使用是否在您账户的限制范围内。每个注册 Picovoice 控制台的人都会收到这里描述的"免费层"使用权限。如果您希望增加限制，可以购买订阅计划。

语言支持

Cheetah 流式语音转文本目前仅支持英语。
对于商业客户，可根据具体情况提供额外语言支持。

演示

Python 演示

安装演示包：

pip3 install pvcheetahdemo

cheetah_demo_mic --access_key ${ACCESS_KEY}

将 ${ACCESS_KEY} 替换为您从 Picovoice 控制台获得的访问密钥。

C 演示

如果使用 SSH，请使用以下命令克隆仓库：

git clone --recurse-submodules git@github.com:Picovoice/cheetah.git

如果使用 HTTPS，请使用以下命令克隆仓库：

git clone --recurse-submodules https://github.com/Picovoice/cheetah.git

构建演示：

cmake -S demo/c/ -B demo/c/build && cmake --build demo/c/build

运行演示：

./demo/c/build/cheetah_demo_mic -a ${ACCESS_KEY} -m ${MODEL_PATH} -l ${LIBRARY_PATH}

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获取的密钥，${LIBRARY_PATH} 替换为 lib 下适当的库路径，${MODEL_PATH} 替换为默认模型文件的路径（或您的自定义模型）。

iOS 演示

要运行演示，转到 demo/ios/CheetahDemo 并运行：

pod install

在 ViewModel.swift 文件中，将 let accessKey = "${YOUR_ACCESS_KEY_HERE}" 替换为您的 AccessKey。

然后，使用 Xcode，打开生成的 CheetahDemo.xcworkspace 并运行应用程序。

Android 演示

使用 Android Studio，将 demo/android/CheetahDemo 作为 Android 项目打开，然后运行应用程序。

在 MainActivity.java 文件中，将 "${YOUR_ACCESS_KEY_HERE}" 替换为您的 AccessKey。

Flutter 演示

要在 Android 或 iOS 上使用 Flutter 运行 Cheetah 演示，您必须在系统上安装 Flutter SDK。安装完成后，可以运行 flutter doctor 来确定相关平台的任何其他缺失要求。设置好环境后，启动模拟器或连接 Android/iOS 设备。

在启动应用程序之前，使用 copy_assets.sh 脚本将 Cheetah 演示模型文件复制到演示项目中。（注意：在 Windows 上，需要 Git Bash 或其他 bash shell，否则您必须手动将上下文复制到项目中。）

在 main.dart 文件中，将 "${YOUR_ACCESS_KEY_HERE}" 替换为您的 AccessKey。

从 demo/flutter 运行以下命令，以构建和部署演示到您的设备：

flutter run

Go 演示

该演示需要 cgo，在 Windows 上可能意味着您需要安装 gcc 编译器（如 MinGW）才能正确构建。

从 demo/go 在终端运行以下命令以构建和运行文件演示：

go run micdemo/cheetah_mic_demo.go -access_key "${ACCESS_KEY}"

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获取的密钥。

有关 Go 演示的更多信息，请转到 demo/go。

React Native 演示

要运行 React Native Cheetah 演示应用程序，您首先需要设置 React Native 环境。为此，请参阅 React Native 文档。环境设置完成后，导航到 demo/react-native 运行以下命令：

对于 Android：

yarn android-install    # 设置环境
yarn android-run        # 构建并部署到 Android

对于 iOS：

yarn ios-install        # 设置环境
yarn ios-run

Node.js 演示

安装演示包：

yarn global add @picovoice/cheetah-node-demo

将工作麦克风连接到您的设备后，在终端中运行以下命令：

cheetah-mic-demo --access_key ${ACCESS_KEY}

有关 Node.js 演示的更多信息，请转到 demo/nodejs。

Java 演示

Cheetah Java 演示是一个命令行应用程序，让您可以选择在音频文件或实时麦克风输入上运行 Cheetah。

要尝试实时演示，请确保有一个工作的麦克风连接到您的设备。然后从终端调用以下命令：

cd demo/java
./gradlew build
cd build/libs
java -jar cheetah-mic-demo.jar -a ${ACCESS_KEY}

有关 Java 演示的更多信息，请转到 demo/java。

.NET 演示

Cheetah .NET 演示是一个命令行应用程序，让您可以选择在音频文件或实时麦克风输入上运行 Cheetah。

确保有一个工作的麦克风连接到您的设备。从 demo/dotnet/CheetahDemo 在终端中运行以下命令：

dotnet run -c MicDemo.Release -- --access_key ${ACCESS_KEY}

将 ${ACCESS_KEY} 替换为您的 Picovoice AccessKey。

有关 .NET 演示的更多信息，请转到 demo/dotnet。

Rust 演示

Cheetah Rust 演示是一个命令行应用程序，让您可以选择在音频文件或实时麦克风输入上运行 Cheetah。

确保有一个工作的麦克风连接到您的设备。从 demo/rust/micdemo 在终端中运行以下命令：

cargo run --release -- --access_key ${ACCESS_KEY}

将 ${ACCESS_KEY} 替换为您的 Picovoice AccessKey。

有关 Rust 演示的更多信息，请转到 demo/rust。

Web 演示

原生 JavaScript 和 HTML

从 demo/web 在终端中运行以下命令：

yarn
yarn start

（或）

npm install
npm run start

在浏览器中打开 http://localhost:5000 来尝试演示。

React 演示

从 demo/react 在终端中运行以下命令：

yarn
yarn start

（或）

npm install
npm run start

在浏览器中打开 http://localhost:3000 来尝试演示。

SDK

Python

安装 Python SDK：

pip3 install pvcheetah

创建引擎实例并实时转录音频：

import pvcheetah

handle = pvcheetah.create(access_key='${ACCESS_KEY}')

def get_next_audio_frame():
    pass

while True:
    partial_transcript, is_endpoint = handle.process(get_next_audio_frame())
    if is_endpoint:
        final_transcript = handle.flush()

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获取的密钥。

C

创建引擎实例并实时转录音频：

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#include "pv_cheetah.h"

pv_cheetah_t *handle = NULL;
const pv_status_t status = pv_cheetah_init("${ACCESS_KEY}", "${MODEL_PATH}", 0.f, false, &handle);
if (status != PV_STATUS_SUCCESS) {
    // 错误处理逻辑
}

extern const int16_t *get_next_audio_frame(void);

while (true) {
    char *partial_transcript = NULL;
    bool is_endpoint = false;
    const pv_status_t status = pv_cheetah_process(
            handle,
            get_next_audio_frame(),
            &partial_transcript,
            &is_endpoint);
    if (status != PV_STATUS_SUCCESS) {
        // 错误处理逻辑
    }
    // 处理转录结果
    free(partial_transcript);
    if (is_endpoint) {
        char *final_transcript = NULL;
        const pv_status_t status = pv_cheetah_flush(handle, &final_transcript);
        if (status != PV_STATUS_SUCCESS) {
            // 错误处理逻辑
        }
        // 处理最终转录结果
        free(final_transcript);
    }
}

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获得的密钥，将 ${MODEL_PATH} 替换为默认模型文件的路径（或您的自定义模型）。最后，完成后请务必使用 pv_cheetah_delete(handle) 释放获取的资源。

iOS

Cheetah iOS 绑定可通过 CocoaPods 获得。要将其导入到您的 iOS 项目中，请在 Podfile 中添加以下行并运行 pod install：

pod 'Cheetah-iOS'

创建引擎实例并实时转录音频：

import Cheetah

let modelPath = Bundle(for: type(of: self)).path(
        forResource: "${MODEL_FILE}", // Cheetah 模型文件名
        ofType: "pv")!

let cheetah = Cheetah(accessKey: "${ACCESS_KEY}", modelPath: modelPath)

func getNextAudioFrame() -> [Int16] {
  // .. 获取音频帧
  return audioFrame;
}

while true {
  do {
    let partialTranscript, isEndpoint = try cheetah.process(getNetAudioFrame())
    if isEndpoint {
      let finalTranscript = try cheetah.flush()
    }
  } catch let error as CheetahError {
      // 处理错误
  } catch { }
}

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获得的密钥，将 ${MODEL_FILE} 替换为从 Picovoice Console 获得的自定义训练模型或默认模型。

Android

要在 Android 项目中包含该包，请确保在顶级 build.gradle 文件中包含了 mavenCentral()，然后在应用的 build.gradle 中添加以下内容：

dependencies {
    implementation 'ai.picovoice:cheetah-android:${LATEST_VERSION}'
}

创建引擎实例并实时转录音频：

import ai.picovoice.cheetah.*;

final String accessKey = "${ACCESS_KEY}"; // 从 Picovoice Console 获得的 AccessKey (https://console.picovoice.ai/)
final String modelPath = "${MODEL_FILE}";

short[] getNextAudioFrame() {
    // .. 获取音频帧
    return audioFrame;
}

try {
    Cheetah cheetah = new Cheetah.Builder().setAccessKey(accessKey).setModelPath(modelPath).build(appContext);

    String transcript = "";

    while true {
        CheetahTranscript transcriptObj = cheetah.process(getNextAudioFrame());
        transcript += transcriptObj.getTranscript();

        if (transcriptObj.getIsEndpoint()) {
            CheetahTranscript finalTranscriptObj = cheetah.flush();
            transcript += finalTranscriptObj.getTranscript();
        }
    };

} catch (CheetahException ex) { }

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获得的密钥，将 ${MODEL_FILE} 替换为从 console 获得的默认或自定义训练模型。

Flutter

在 pub.yaml 中添加 Cheetah Flutter 插件。

dependencies:
  cheetah_flutter: ^<版本>

创建引擎实例并实时转录音频：

import 'package:cheetah_flutter/cheetah.dart';

const accessKey = "{ACCESS_KEY}"  // 从 Picovoice Console 获得的 AccessKey (https://console.picovoice.ai/)

List<int> buffer = getAudioFrame();

try{
    Cheetah _cheetah = await Cheetah.create(accessKey, '{CHEETAH_MODEL_PATH}');

    String transcript = "";

    while true {
        CheetahTranscript partialResult = await _cheetah.process(getAudioFrame());
        transcript += partialResult.transcript;

        if (partialResult.isEndpoint) {
            CheetahTranscript finalResult = await _cheetah.flush();
            transcript += finalResult.transcript;
        }
    }

    _cheetah.delete()

} on CheetahException catch (err) { }

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获得的 AccessKey，将 ${CHEETAH_MODEL_PATH} 替换为从 Picovoice Console 获得的自定义训练模型路径或默认模型路径。

Go

安装 Go 绑定：

go get github.com/Picovoice/cheetah/binding/go

创建引擎实例并实时转录音频：

import . "github.com/Picovoice/cheetah/binding/go"

cheetah = NewCheetah{AccessKey: "${ACCESS_KEY}"}
err := cheetah.Init()
if err != nil {
    // 处理初始化错误
}
defer cheetah.Delete()

func getNextFrameAudio() []int16{
    // 获取音频帧
}

for {
  partialTranscript, isEndpoint, err = cheetah.Process(getNextFrameAudio())
  if isEndpoint {
    finalTranscript, err = cheetah.Flush()
    }
}

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获得的密钥。完成后，请务必使用 cheetah.Delete() 显式释放资源。

React Native

Cheetah React Native 绑定可通过 NPM 获得。使用以下命令添加：

yarn add @picovoice/cheetah-react-native

创建引擎实例并转录音频文件：

import {Cheetah, CheetahErrors} from '@picovoice/cheetah-react-native';

const getAudioFrame = () => {
  // 获取音频帧
}

try {
  while (1) {
    const cheetah = await Cheetah.create("${ACCESS_KEY}", "${MODEL_FILE}")
    const {transcript, isEndpoint} = await cheetah.process(getAudioFrame())
    if (isEndpoint) {
      const {transcript} = await cheetah.flush()
    }
  }
} catch (err: any) {
  if (err instanceof CheetahErrors) {
    // 处理错误
  }
}

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获得的密钥，将 ${MODEL_FILE} 替换为从 console 获得的默认或自定义训练模型。完成后，请务必使用 cheetah.delete() 显式释放资源。

Node.js

安装 Node.js SDK：

yarn add @picovoice/cheetah-node

创建 Cheetah 类的实例：

const Cheetah = require("@picovoice/cheetah-node");

const accessKey = "${ACCESS_KEY}"; // 从 Picovoice Console 获得 (https://console.picovoice.ai/)
const endpointDurationSec = 0.2;
const handle = new Cheetah(accessKey);

function getNextAudioFrame() {
  // ...
  return audioFrame;
}

while (true) {
  const audioFrame = getNextAudioFrame();
  const [partialTranscript, isEndpoint] = handle.process(audioFrame);
  if (isEndpoint) {
    finalTranscript = handle.flush()
  }
}

将 ${ACCESS_KEY} 替换为从 Picovoice Console 获得的密钥。

完成后，请务必使用 release() 释放资源：

handle.release();

Java

使用 Cheetah Builder 类创建引擎实例并实时转录音频：

import ai.picovoice.cheetah.*;
final String accessKey = "..."; // Picovoice控制台提供的AccessKey (https://console.picovoice.ai/)

short[] getNextAudioFrame() {
    // .. 获取音频帧
    return audioFrame;
}

String transcript = "";

try {
    Cheetah cheetah = new Cheetah.Builder().setAccessKey(accessKey).build();

    while (true) {
        CheetahTranscript transcriptObj = cheetah.process(getNextAudioFrame());
        transcript += transcriptObj.getTranscript();

        if (transcriptObj.getIsEndpoint()) {
            CheetahTranscript finalTranscriptObj = cheetah.flush();
            transcript += finalTranscriptObj.getTranscript();
        }
    }

    cheetah.delete();

} catch (CheetahException ex) { }

.NET

使用NuGet或dotnet CLI安装.NET SDK:

dotnet add package Cheetah

SDK提供了一个工厂方法来创建引擎实例,如下所示:

using Pv;

const string accessKey = "${ACCESS_KEY}";

Cheetah handle = Cheetah.Create(accessKey);

将${ACCESS_KEY}替换为从Picovoice控制台(https://console.picovoice.ai/)获得的密钥。

初始化后,有效的采样率由handle.SampleRate给出。预期的帧长度(输入数组中的音频样本数)是handle.FrameLength。引擎接受16位线性PCM编码,并对单通道音频进行操作。

short[] GetNextAudioFrame()
{
    // .. 获取音频帧
    return audioFrame;
}

string transcript = "";

while(true)
{
    CheetahTranscript transcriptObj = handle.Process(GetNextAudioFrame());
    transcript += transcriptObj.Transcript;

    if (transcriptObj.IsEndpoint) {
        CheetahTranscript finalTranscriptObj = handle.Flush();
        transcript += finalTranscriptObj.Transcript;
    }
}

Cheetah的资源将由垃圾收集器释放,但要在使用后立即释放资源,可以将其包装在using语句中:

using(Cheetah handle = Cheetah.Create(accessKey))
{
    // .. 这里使用Cheetah
}

Rust

首先需要在系统上安装Rust和Cargo。

要将cheetah库添加到您的应用程序中,请在应用程序的Cargo.toml清单中添加pv_cheetah:

[dependencies]
pv_cheetah = "*"

使用CheetahBuilder实例创建引擎实例并转录音频文件:

use cheetah::CheetahBuilder;

fn next_audio_frame() -> Vec<i16> {
  // 获取音频帧
}

let access_key = "${ACCESS_KEY}"; // 从Picovoice控制台获得的AccessKey (https://console.picovoice.ai/)
let cheetah: Cheetah = CheetahBuilder::new().access_key(access_key).init().expect("无法创建Cheetah");

if let Ok(cheetahTranscript) = cheetah.process(&next_audio_frame()) {
  println!("{}", cheetahTranscript.transcript)
  if cheetahTranscript.is_endpoint {
    if let Ok(cheetahTranscript) = cheetah.flush() {
      println!("{}", cheetahTranscript.transcript)
    }
  }
}

将${ACCESS_KEY}替换为从Picovoice控制台(https://console.picovoice.ai/)获得的密钥。

Web

原生JavaScript和HTML (ES模块)

使用yarn安装web SDK:

yarn add @picovoice/cheetah-web

或使用npm:

npm install --save @picovoice/cheetah-web

使用CheetahWorker创建引擎实例并转录音频文件:

import { CheetahWorker } from "@picovoice/cheetah-web";
import cheetahParams from "${PATH_TO_BASE64_CHEETAH_PARAMS}";

let transcript = "";

function transcriptCallback(cheetahTranscript: CheetahTranscript) {
  transcript += cheetahTranscript.transcript;
  if (cheetahTranscript.isEndpoint) {
    transcript += "\n";
  }
}

function getAudioData(): Int16Array {
  // ... 获取音频数据的函数
  return new Int16Array();
}

const cheetah = await CheetahWorker.create(
  "${ACCESS_KEY}",
  transcriptCallback,
  { base64: cheetahParams }
);

for (;;) {
  cheetah.process(getAudioData());
  // 在某些条件下中断
}
cheetah.flush(); // 对剩余数据运行transcriptionCallback。

将${ACCESS_KEY}替换为从Picovoice控制台(https://console.picovoice.ai/)获得的密钥。最后,完成后使用cheetah.release()释放资源。

React

yarn add @picovoice/cheetah-react @picovoice/web-voice-processor

(或)

npm install @picovoice/cheetah-react @picovoice/web-voice-processor

import { useCheetah } from "@picovoice/cheetah-react";

function App(props) {
  const {
    result,
    isLoaded,
    isListening,
    error,
    init,
    start,
    stop,
    release,
  } = useCheetah();

  const initEngine = async () => {
    await init(
      "${ACCESS_KEY}",
      cheetahModel,
    );
  };

  const toggleRecord = async () => {
    if (isListening) {
      await stop();
    } else {
      await start();
    }
  };

  useEffect(() => {
    if (result !== null) {
      console.log(result.transcript);
      console.log(result.isComplete);
    }
  }, [result])
}