#ffi #speech #deep-learning #microsoft #luis

sys luis_sys

FFI bindings for Microsoft LUIS API

26 releases

✓ Uses Rust 2018 edition

new 0.4.3 Jun 25, 2019
0.4.2 Jun 18, 2019
0.3.24 Jun 12, 2019
0.3.21 May 31, 2019
0.3.11 Mar 15, 2019

#56 in Asynchronous

Download history 49/week @ 2019-03-12 18/week @ 2019-03-19 145/week @ 2019-03-26 22/week @ 2019-04-02 26/week @ 2019-04-09 1/week @ 2019-04-16 3/week @ 2019-04-23 23/week @ 2019-04-30 36/week @ 2019-05-07 48/week @ 2019-05-14 93/week @ 2019-05-21 73/week @ 2019-05-28 62/week @ 2019-06-04 71/week @ 2019-06-11 132/week @ 2019-06-18

197 downloads per month

MIT license

269KB
2.5K SLoC

luis_sys

Rust FFI bindings for Microsoft LUIS API.

A rust style wrapper for Microsoft LUIS C/C++ SDK.

Usage

Add luis_sys to the dependencies section in your project's Cargo.toml, with

[dependencies]
luis_sys = "^0.3.8"

Note: The crate includes Cognitive Services Speech SDK Linux Version 1.3.1. Windows version is not tested.

Example

Create entry main function with crates of luis_sys, logger and futures.

use env_logger;
use futures::{Future, Stream};
use log::{error, info};
use luis_sys::{builder::RecognizerConfig, events::Flags, Result};
use std::env;
use tokio;

fn main() {
    env::set_var("RUST_BACKTRACE", "1");
    env::set_var("RUST_LOG", "debug");
    env_logger::init();

    info!("Start ASR test...");
    recognize_test().unwrap();
    info!("Stop ASR test...");
}

Construct a builder by subscription info with configurations. The audio input is a wav file in example folder.

    let mut factory = RecognizerConfig::from_subscription(
        "YourLanguageUnderstandingSubscriptionKey",
        "YourLanguageUnderstandingServiceRegion",
    )?;

    // Choose the events to subscribe.
    let flags = Flags::Recognition
        | Flags::SpeechDetection
        | Flags::Session
        | Flags::Connection
        | Flags::Canceled;

    // Add intents if you want a intent recognizer. They are phrases or intents names of a pre-trained language understanding model.
    let intents = vec![
        "否定".to_string(),
        "肯定".to_string(),
        "中秋快乐祝你们平安无事快乐健康的生活".to_string(),
        "祝福".to_string(),
    ];

    factory
        .set_flags(flags)
        .set_audio_file_path("examples/chinese_test.wav")
        .set_model_id("YourLanguageUnderstandingAppId")
        .set_intents(intents)
        .put_language("TheLanguageOfAudioInput")?;
        .put_detailed_result(true)?;

factory.recognizer() build a speech recognition only recognizer. factory.intent_recognizer() build a speech intent recognizer.

Starts blocked intent recognition, and returns after a single utterance. The end of a single utterance is determined by listening for silence at the end or until a maximum of 15 seconds of audio is processed.

fn recognize_once(factory: &RecognizerConfig) -> Result {
    info!("Synchronous ASR ");
    let recognizer = factory.recognizer()?;
    let result = recognizer.recognize()?;
    info!("done: {}", result);
    Ok(())
}

Asynchronous intent recognition in tokio runtime.

fn recognize_stream(factory: &RecognizerConfig) -> Result {
    info!("Asynchronous ASR, streaming Event object");
    let mut reco = factory.intent_recognizer()?;
    let promise = reco
        .start()?
        // Add event filter to choice events you care.
        .set_filter(Flags::Recognized | Flags::SpeechDetection)
        .for_each(|msg| {
            info!("result: {:?}", msg.into_result());
            Ok(())
        });
    tokio::run(promise);
    Ok(())
}

Translate and synthesis audio.

factory
    // Add one or many target languages to tranlate from speech.
    .add_target_language("en")?
    // Enable audio synthesis output.
    .put_translation_features("textToSpeech")?
    // Select voice name appropriate for the target language.
    .put_voice_name("Microsoft Server Speech Text to Speech Voice (en-US, JessaRUS)")?;

info!("Asynchronous translation and audio synthesis");
let mut reco = factory.translator()?;
let promise = reco
    .start()?
    .set_filter(Flags::Recognized | Flags::Synthesis)
    .for_each(|evt| {
        // Handle the translation or synthesis result.
        Ok(())
    })
    .map_err(|err| error!("{}", err));

tokio::run(promise);

EventStream returned by Recognizer::start is implemented futures::Stream for asynchronous operation. And it can be refined by set_filter, resulting, json and text to pump different format results. And you can do that and more by Future/Stream combinations.

Versions

See the change log.

Notice

  • The crate is working in progress, carefully if apply in production.

  • Only speech SDK of LUIS service has C/C++ version. So current version supports very few feature of LUIS while LUIS SDK is in fast evolution phase.

  • Windows version SDK is not tested.

  • Linux version SDK only support Ubuntu distribution currently.

  • Please read the prerequisites at first.

Dependencies

~6MB
~112K SLoC