Add files via upload

2026-06-27 19:13:08 +08:00 · 2018-12-22 19:58:36 +08:00
commit 3cd5ceaa12
13 changed files with 786 additions and 0 deletions
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Dec  4 13:52:18 2018
+
+@author: 22029152
+"""
+import numpy as np
+
+parameters_poems = np.load('model_poems.npy')[()]
+embedding_weights_poems = parameters_poems['embedding_weights']
+gru_weights_poems = parameters_poems['gru_weights']
+fc_weights_poems = parameters_poems['fc_weights']
+char2idx_poems = parameters_poems['char2idx']
+idx2char_poems = parameters_poems['idx2char']
+max_length_poems = parameters_poems['max_length']
+embedding_dim_poems = parameters_poems['embedding_dim']
+units_poems = parameters_poems['units'] 
+BATCH_SIZE_poems = parameters_poems['BATCH_SIZE']
+BUFFER_SIZE_poems = parameters_poems['BUFFER_SIZE']
+
+vocab_size_poems = len(dict(idx2char_poems))
+
+# Load hyperparameters and layers' weights previously saved
+parameters_rhymes = np.load('model_rhymes.npy')[()]
+embedding_weights_rhymes = parameters_rhymes['embedding_weights']
+gru_weights_rhymes = parameters_rhymes['gru_weights']
+fc_weights_rhymes = parameters_rhymes['fc_weights']
+word2idx_rhymes = parameters_rhymes['word2idx']
+idx2word_rhymes = parameters_rhymes['idx2word']
+max_length_rhymes = parameters_rhymes['max_length'] 
+embedding_dim_rhymes = parameters_rhymes['embedding_dim']  
+units_rhymes = parameters_rhymes['units']
+BATCH_SIZE_rhymes = parameters_rhymes['BATCH_SIZE']
+BUFFER_SIZE_rhymes = parameters_rhymes['BUFFER_SIZE']
+
+vocab_size_rhymes = len(dict(idx2word_rhymes))
@@ -0,0 +1,419 @@
+# Snowboy Hotword Detection
+
+by [KITT.AI](http://kitt.ai).
+
+[Home Page](https://snowboy.kitt.ai)
+
+[Full Documentation](http://docs.kitt.ai/snowboy) and [FAQ](http://docs.kitt.ai/snowboy#faq)
+
+[Discussion Group](https://groups.google.com/a/kitt.ai/forum/#!forum/snowboy-discussion) (or send email to snowboy-discussion@kitt.ai)
+
+(The discussion group is new since September 2016 as we are getting many messages every day. Please send general questions there. For bugs, use Github issues.)
+
+Version: 1.1.1 (3/24/2017)
+
+## Alexa support
+
+Snowboy now brings hands-free experience to the [Alexa AVS sample app](https://github.com/alexa/alexa-avs-sample-app) on Raspberry Pi! Here is how you can use other Snowboy models
+
+**Personal model**
+* Create your personal hotword model through our [website](https://snowboy.kitt.ai) or [hotword API](https://snowboy.kitt.ai/api/v1/train/)
+* Replace the hotword model in [Alexa AVS sample app](https://github.com/alexa/alexa-avs-sample-app) (after installation) with your personal model
+
+```
+# Please replace YOUR_PERSONAL_MODEL.pmdl with the personal model you just
+# created, and $ALEXA_AVS_SAMPLE_APP_PATH with the actual path where you
+# cloned the Alexa AVS sample app repository.
+cp YOUR_PERSONAL_MODEL.pmdl $ALEXA_AVS_SAMPLE_APP_PATH/samples/wakeWordAgent/ext/resources/alexa.umdl
+```
+
+* Set `APPLY_FRONTEND` to `false` and update `SENSITIVITY` in the [Alexa AVS sample app code](https://github.com/alexa/alexa-avs-sample-app/blob/master/samples/wakeWordAgent/src/KittAiSnowboyWakeWordEngine.cpp) and re-compile
+
+```
+# Please replace $ALEXA_AVS_SAMPLE_APP_PATH with the actual path where you
+# cloned the Alexa AVS sample app repository.
+cd $ALEXA_AVS_SAMPLE_APP_PATH/samples/wakeWordAgent/src/
+
+# Modify KittAiSnowboyWakeWordEngine.cpp and update SENSITIVITY at line 28.
+# Modify KittAiSnowboyWakeWordEngine.cpp and set APPLY_FRONTEND to false at
+# line 30.
+make
+```
+
+* Run the wake word agent with engine set to `kitt_ai`!
+
+**Universal model**
+* Replace the hotword model in [Alexa AVS sample app](https://github.com/alexa/alexa-avs-sample-app) (after installation) with your universal model
+
+```
+# Please replace YOUR_UNIVERSAL_MODEL.umdl with the personal model you just
+# created, and $ALEXA_AVS_SAMPLE_APP_PATH with the actual path where you
+# cloned the Alexa AVS sample app repository.
+cp YOUR_UNIVERSAL_MODEL.umdl $ALEXA_AVS_SAMPLE_APP_PATH/samples/wakeWordAgent/ext/resources/alexa.umdl
+```
+
+* Update `SENSITIVITY` in the [Alexa AVS sample app code](https://github.com/alexa/alexa-avs-sample-app/blob/master/samples/wakeWordAgent/src/KittAiSnowboyWakeWordEngine.cpp) and re-compile
+
+```
+# Please replace $ALEXA_AVS_SAMPLE_APP_PATH with the actual path where you
+# cloned the Alexa AVS sample app repository.
+cd $ALEXA_AVS_SAMPLE_APP_PATH/samples/wakeWordAgent/src/
+
+# Modify KittAiSnowboyWakeWordEngine.cpp and update SENSITIVITY at line 28.
+make
+```
+
+* Run the wake word agent with engine set to `kitt_ai`!
+
+
+## Hotword as a Service
+
+Snowboy now offers **Hotword as a Service** through the ``https://snowboy.kitt.ai/api/v1/train/``
+endpoint. Check out the [Full Documentation](http://docs.kitt.ai/snowboy) and example [Python/Bash script](examples/REST_API) (other language contributions are very welcome).
+
+As a quick start, ``POST`` to https://snowboy.kitt.ai/api/v1/train:
+
+	{
+	    "name": "a word",
+	    "language": "en",
+	    "age_group": "10_19",
+	    "gender": "F",
+	    "microphone": "mic type",
+	    "token": "<your auth token>",
+	    "voice_samples": [
+	        {wave: "<base64 encoded wave data>"},
+	        {wave: "<base64 encoded wave data>"},
+	        {wave: "<base64 encoded wave data>"}
+	    ]
+	}
+
+then you'll get a trained personal model in return!
+
+## Introduction
+
+Snowboy is a customizable hotword detection engine for you to create your own
+hotword like "OK Google" or "Alexa". It is powered by deep neural networks and
+has the following properties:
+
+* **highly customizable**: you can freely define your own magic phrase here –
+let it be “open sesame”, “garage door open”, or “hello dreamhouse”, you name it.
+
+* **always listening** but protects your privacy: Snowboy does not use Internet
+and does *not* stream your voice to the cloud.
+
+* light-weight and **embedded**: it even runs on a Raspberry Pi and consumes
+less than 10% CPU on the weakest Pi (single-core 700MHz ARMv6).
+
+* Apache licensed!
+
+Currently Snowboy supports:
+
+* all versions of Raspberry Pi (with Raspbian based on Debian Jessie 8.0)
+* 64bit Mac OS X
+* 64bit Ubuntu (12.04 and 14.04)
+* iOS
+* Android
+* Pine64 (Debian Jessie 8.5, 3.10.102 BSP2)
+* Intel Edison (Ubilinux based on Debian Wheezy 7.8)
+* Samsung Artik (built with Fedora 25 for ARMv7)
+
+It ships in the form of a **C++ library** with language-dependent wrappers
+generated by SWIG. We welcome wrappers for new languages -- feel free to send a
+pull request!
+
+Currently we have built wrappers for:
+
+* Java/Android
+* Go (thanks to @brentnd)
+* Node (thanks to @evancohen)
+* Perl (thanks to @iboguslavsky)
+* Python
+* iOS/Swift3 (thanks to @grimlockrocks)
+* iOS/Object-C (thanks to @patrickjquinn)
+
+If you want support on other hardware/OS, please send your request to
+[snowboy@kitt.ai](mailto:snowboy.kitt.ai)
+
+Note: **Snowboy does not support Windows** yet. Please build Snowboy on *nix platforms.
+
+## Pricing for Snowboy models
+
+Hackers: free
+
+* Personal use
+* Community support
+
+Business: please contact us at [snowboy@kitt.ai](mailto:snowboy@kitt.ai)
+
+* Personal use
+* Commercial license
+* Technical support
+
+## Pretrained universal models
+
+We provide pretrained universal models for testing purpose. When you test those
+models, bear in mind that they may not be optimized for your specific device or
+environment.
+
+Here is the list of the models, and the parameters that you have to use for them:
+
+* **resources/snowboy.umdl**: Universal model for the hotword "Snowboy". Set
+SetSensitivity to 0.5 for better performance.
+* **resources/alexa.umdl**: Universal model for the hotword "Alexa". Set
+SetSensitivity to 0.5, and preferably set ApplyFrontend to true. This model is
+depressed.
+* **resources/alexa_02092017.umdl**: Universal model for the hotword "Alexa". This
+is still work in progress. Set SetSensitivity to 0.15.
+
+## Precompiled node module
+
+Snowboy is available in the form of a native node module precompiled for:
+64 bit Ubuntu, MacOS X, and the Raspberry Pi (Raspbian 8.0+). For quick
+installation run:
+
+    npm install --save snowboy
+
+For sample usage see the `examples/Node` folder. You may have to install
+dependencies like `fs`, `wav` or `node-record-lpcm16` depending on which script
+you use.
+
+## Precompiled Binaries with Python Demo
+* 64 bit Ubuntu [12.04](https://s3-us-west-2.amazonaws.com/snowboy/snowboy-releases/ubuntu1204-x86_64-1.1.1.tar.bz2)
+  / [14.04](https://s3-us-west-2.amazonaws.com/snowboy/snowboy-releases/ubuntu1404-x86_64-1.1.1.tar.bz2)
+* [MacOS X](https://s3-us-west-2.amazonaws.com/snowboy/snowboy-releases/osx-x86_64-1.1.1.tar.bz2)
+* Raspberry Pi with Raspbian 8.0, all versions
+  ([1/2/3/Zero](https://s3-us-west-2.amazonaws.com/snowboy/snowboy-releases/rpi-arm-raspbian-8.0-1.1.1.tar.bz2))
+* Pine64 (Debian Jessie 8.5 (3.10.102)) ([download](https://s3-us-west-2.amazonaws.com/snowboy/snowboy-releases/pine64-debian-jessie-1.1.1.tar.bz2))
+* Intel Edison (Ubilinux based on Debian Wheezy 7.8) ([download](https://s3-us-west-2.amazonaws.com/snowboy/snowboy-releases/edison-ubilinux-1.1.1.tar.bz2))
+  
+If you want to compile a version against your own environment/language, read on.
+
+## Dependencies
+
+To run the demo you will likely need the following, depending on which demo you
+use and what platform you are working with:
+
+* SoX (audio conversion)
+* PortAudio or PyAudio (audio capturing)
+* SWIG 3.0.10 or above (compiling Snowboy for different languages/platforms)
+* ATLAS or OpenBLAS (matrix computation)
+
+You can also find the exact commands you need to install the dependencies on
+Mac OS X, Ubuntu or Raspberry Pi below.
+
+### Mac OS X
+
+`brew` install `swig`, `sox`, `portaudio` and its Python binding `pyaudio`:
+
+    brew install swig portaudio sox
+    pip install pyaudio
+
+If you don't have Homebrew installed, please download it [here](http://brew.sh/). If you don't have `pip`, you can install it [here](https://pip.pypa.io/en/stable/installing/).
+
+Make sure that you can record audio with your microphone:
+
+    rec t.wav
+
+### Ubuntu/Raspberry Pi/Pine64
+
+First `apt-get` install `swig`, `sox`, `portaudio` and its Python binding `pyaudio`:
+
+    sudo apt-get install swig3.0 python-pyaudio python3-pyaudio sox
+    pip install pyaudio
+    
+Then install the `atlas` matrix computing library:
+
+    sudo apt-get install libatlas-base-dev
+    
+Make sure that you can record audio with your microphone:
+
+    rec t.wav
+        
+If you need extra setup on your audio (especially on a Raspberry Pi), please see the [full documentation](http://docs.kitt.ai/snowboy).
+
+## Compile a Node addon
+Compiling a node addon for Linux and the Raspberry Pi requires the installation of the following dependencies:
+
+    sudo apt-get install libmagic-dev libatlas-base-dev
+
+Then to compile the addon run the following from the root of the snowboy repository:
+
+    node-pre-gyp clean configure build
+
+## Compile a Java Wrapper
+
+    # Make sure you have JDK installed.
+    cd swig/Java
+    make
+
+SWIG will generate a directory called `java` which contains converted Java wrappers and a directory called `jniLibs` which contains the JNI library.
+
+To run the Java example script:
+
+    cd examples/Java
+    make run
+
+## Compile a Python Wrapper
+
+    cd swig/Python
+    make
+
+SWIG will generate a `_snowboydetect.so` file and a simple (but hard-to-read) python wrapper `snowboydetect.py`. We have provided a higher level python wrapper `snowboydecoder.py` on top of that.
+    
+Feel free to adapt the `Makefile` in `swig/Python` to your own system's setting if you cannot `make` it.
+
+## Compile a GO Wrapper
+
+	cd examples/Go
+	go get github.com/Kitt-AI/snowboy/swig/Go
+	go build -o snowboy main.go
+	./snowboy ../../resources/snowboy.umdl ../../resources/snowboy.wav
+	
+Expected Output:
+
+```
+Snowboy detecting keyword in ../../resources/snowboy.wav
+Snowboy detected keyword  1
+```
+
+For more, please read `examples/Go/readme.md`.
+
+## Compile a Perl Wrapper
+
+    cd swig/Perl
+    make
+
+The Perl examples include training personal hotword using the KITT.AI RESTful APIs, adding Google Speech API after the hotword detection, etc. To run the examples, do the following
+
+    cd examples/Perl
+
+    # Install cpanm, if you don't already have it.
+    curl -L https://cpanmin.us | perl - --sudo App::cpanminus
+
+    # Install the dependencies. Note, on Linux you will have to install the
+    # PortAudio package first, using e.g.:
+    # apt-get install portaudio19-dev
+    sudo cpanm --installdeps .
+
+    # Run the unit test.
+    ./snowboy_unit_test.pl
+
+    # Run the personal model training example.
+    ./snowboy_RESTful_train.pl <API_TOKEN> <Hotword> <Language>
+
+    # Run the Snowboy Google Speech API example. By default it uses the Snowboy
+    # universal hotword.
+    ./snowboy_googlevoice.pl <Google_API_Key> [Hotword_Model]
+
+
+## Compile an iOS Wrapper
+
+Using Snowboy library in Objective-C does not really require a wrapper. It is basically the same as using C++ library in Objective-C. We have compiled a "fat" static library for iOS devices, see the library here `lib/ios/libsnowboy-detect.a`.
+
+To initialize Snowboy detector in Objective-C:
+
+    snowboy::SnowboyDetect* snowboyDetector = new snowboy::SnowboyDetect(
+        std::string([[[NSBundle mainBundle]pathForResource:@"common" ofType:@"res"] UTF8String]),
+        std::string([[[NSBundle mainBundle]pathForResource:@"snowboy" ofType:@"umdl"] UTF8String]));
+    snowboyDetector->SetSensitivity("0.45");        // Sensitivity for each hotword
+    snowboyDetector->SetAudioGain(2.0);             // Audio gain for detection
+
+To run hotword detection in Objective-C:
+
+    int result = snowboyDetector->RunDetection(buffer[0], bufferSize);  // buffer[0] is a float array
+
+You may want to play with the frequency of the calls to `RunDetection()`, which controls the CPU usage and the detection latency.
+
+Thanks to @patrickjquinn and @grimlockrocks, we now have examples of using Snowboy in both Objective-C and Swift3. Check out the examples at `examples/iOS/`, and the screenshots below!
+
+<img src=https://s3-us-west-2.amazonaws.com/kittai-cdn/Snowboy/Obj-C_Demo_02172017.png alt="Obj-C Example" width=300 /> <img src=https://s3-us-west-2.amazonaws.com/kittai-cdn/Snowboy/Swift3_Demo_02172017.png alt="Swift3 Example" width=300 />
+
+
+## Compile an Android Wrapper
+
+Full README and tutorial is in [Android README](examples/Android/README.md) and here's a screenshot:
+
+<img src="https://s3-us-west-2.amazonaws.com/kittai-cdn/Snowboy/SnowboyAlexaDemo-Andriod.jpeg" alt="Android Alexa Demo" width=300 />
+
+
+## Quick Start for Python Demo
+
+Go to the `examples/Python` folder and open your python console:
+
+    In [1]: import snowboydecoder
+    
+    In [2]: def detected_callback():
+       ....:     print "hotword detected"
+       ....:
+    
+    In [3]: detector = snowboydecoder.HotwordDetector("resources/snowboy.umdl", sensitivity=0.5, audio_gain=1)
+    
+    In [4]: detector.start(detected_callback)
+    
+Then speak "snowboy" to your microphone to see whetheer Snowboy detects you.
+
+The `snowboy.umdl` file is a "universal" model that detect different people speaking "snowboy". If you want other hotwords, please go to [snowboy.kitt.ai](https://snowboy.kitt.ai) to record, train and downloand your own personal model (a `.pmdl` file).
+
+When `sensitiviy` is higher, the hotword gets more easily triggered. But you might get more false alarms.
+
+`audio_gain` controls whether to increase (>1) or decrease (<1) input volume.
+
+Two demo files `demo.py` and `demo2.py` are provided to show more usages.
+
+Note: if you see the following error:
+
+    TypeError: __init__() got an unexpected keyword argument 'model_str'
+    
+You are probably using an old version of SWIG. Please upgrade. We have tested with SWIG version 3.0.7 and 3.0.8.
+
+## Advanced Usages & Demos
+
+See [Full Documentation](http://docs.kitt.ai/snowboy).
+
+## Change Log
+
+**v1.1.1, 3/24/2017**
+
+* Added Android demo
+* Added iOS demos
+* Added Samsung Artik support
+* Added Go support
+* Added Intel Edison support
+* Added Pine64 support
+* Added a more robust "Alexa" model (umdl)
+* Offering Hotword as a Service through ``/api/v1/train`` endpoint.
+* Decoder is not changed.
+
+**v1.1.0, 9/20/2016**
+
+* Added library for Node.
+* Added support for Python3.
+* Added universal model `alexa.umdl`
+* Updated universal model `snowboy.umdl` so that it works in noisy environment.
+
+**v1.0.4, 7/13/2016**
+
+* Updated universal `snowboy.umdl` model to make it more robust.
+* Various improvements to speed up the detection.
+* Bug fixes.
+
+**v1.0.3, 6/4/2016**
+
+* Updated universal `snowboy.umdl` model to make it more robust in non-speech environment.
+* Fixed bug when using float as input data.
+* Added library support for Android ARMV7 architecture.
+* Added library for iOS.
+
+**v1.0.2, 5/24/2016**
+
+* Updated universal `snowboy.umdl` model
+* added C++ examples, docs will come in next release.
+
+**v1.0.1, 5/16/2016**
+
+* VAD now returns -2 on silence, -1 on error, 0 on voice and >0 on triggered models
+* added static library for Raspberry Pi in case people want to compile themselves instead of using the binary version
+
+**v1.0.0, 5/10/2016**
+
+* initial release
@@ -0,0 +1,187 @@
+#!/usr/bin/env python
+
+import collections
+import pyaudio
+import snowboydetect
+import time
+import wave
+import os
+import logging
+
+logging.basicConfig()
+logger = logging.getLogger("snowboy")
+logger.setLevel(logging.INFO)
+TOP_DIR = os.path.dirname(os.path.abspath(__file__))
+
+RESOURCE_FILE = os.path.join(TOP_DIR, "resources/common.res")
+DETECT_DING = os.path.join(TOP_DIR, "resources/ding.wav")
+DETECT_DONG = os.path.join(TOP_DIR, "resources/dong.wav")
+DETECT_PY   = os.path.join(TOP_DIR, "BitLit_main.py")  ## ADDED
+
+
+class RingBuffer(object):
+    """Ring buffer to hold audio from PortAudio"""
+    def __init__(self, size = 4096):
+        self._buf = collections.deque(maxlen=size)
+
+    def extend(self, data):
+        """Adds data to the end of buffer"""
+        self._buf.extend(data)
+
+    def get(self):
+        """Retrieves data from the beginning of buffer and clears it"""
+        tmp = bytes(bytearray(self._buf))
+        self._buf.clear()
+        return tmp
+
+###
+def run(fname=DETECT_PY):
+    Py_wav=os.system('python BitLit_main.py')
+###    
+def play_audio_file(fname=DETECT_DING):
+    """Simple callback function to play a wave file. By default it plays
+    a Ding sound.
+
+    :param str fname: wave file name
+    :return: None
+    """
+    ding_wav = wave.open(fname, 'rb')
+    ding_data = ding_wav.readframes(ding_wav.getnframes())
+    audio = pyaudio.PyAudio()
+    stream_out = audio.open(
+        format=audio.get_format_from_width(ding_wav.getsampwidth()),
+        channels=ding_wav.getnchannels(),
+        rate=ding_wav.getframerate(), input=False, output=True)
+    stream_out.start_stream()
+    stream_out.write(ding_data)
+    time.sleep(0.2)
+    stream_out.stop_stream()
+    stream_out.close()
+    audio.terminate()
+
+
+class HotwordDetector(object):
+    """
+    Snowboy decoder to detect whether a keyword specified by `decoder_model`
+    exists in a microphone input stream.
+
+    :param decoder_model: decoder model file path, a string or a list of strings
+    :param resource: resource file path.
+    :param sensitivity: decoder sensitivity, a float of a list of floats.
+                              The bigger the value, the more senstive the
+                              decoder. If an empty list is provided, then the
+                              default sensitivity in the model will be used.
+    :param audio_gain: multiply input volume by this factor.
+    """
+    def __init__(self, decoder_model,
+                 resource=RESOURCE_FILE,
+                 sensitivity=[],
+                 audio_gain=1):
+
+        def audio_callback(in_data, frame_count, time_info, status):
+            self.ring_buffer.extend(in_data)
+            play_data = chr(0) * len(in_data)
+            return play_data, pyaudio.paContinue
+
+        tm = type(decoder_model)
+        ts = type(sensitivity)
+        if tm is not list:
+            decoder_model = [decoder_model]
+        if ts is not list:
+            sensitivity = [sensitivity]
+        model_str = ",".join(decoder_model)
+
+        self.detector = snowboydetect.SnowboyDetect(
+            resource_filename=resource.encode(), model_str=model_str.encode())
+        self.detector.SetAudioGain(audio_gain)
+        self.num_hotwords = self.detector.NumHotwords()
+
+        if len(decoder_model) > 1 and len(sensitivity) == 1:
+            sensitivity = sensitivity*self.num_hotwords
+        if len(sensitivity) != 0:
+            assert self.num_hotwords == len(sensitivity), \
+                "number of hotwords in decoder_model (%d) and sensitivity " \
+                "(%d) does not match" % (self.num_hotwords, len(sensitivity))
+        sensitivity_str = ",".join([str(t) for t in sensitivity])
+        if len(sensitivity) != 0:
+            self.detector.SetSensitivity(sensitivity_str.encode())
+
+        self.ring_buffer = RingBuffer(
+            self.detector.NumChannels() * self.detector.SampleRate() * 5)
+        self.audio = pyaudio.PyAudio()
+        self.stream_in = self.audio.open(
+            input=True, output=False,
+            format=self.audio.get_format_from_width(
+                self.detector.BitsPerSample() / 8),
+            channels=self.detector.NumChannels(),
+            rate=self.detector.SampleRate(),
+            frames_per_buffer=2048,
+            stream_callback=audio_callback)
+
+
+    def start(self, detected_callback=play_audio_file,
+              interrupt_check=lambda: False,
+              sleep_time=0.03):
+        """
+        Start the voice detector. For every `sleep_time` second it checks the
+        audio buffer for triggering keywords. If detected, then call
+        corresponding function in `detected_callback`, which can be a single
+        function (single model) or a list of callback functions (multiple
+        models). Every loop it also calls `interrupt_check` -- if it returns
+        True, then breaks from the loop and return.
+
+        :param detected_callback: a function or list of functions. The number of
+                                  items must match the number of models in
+                                  `decoder_model`.
+        :param interrupt_check: a function that returns True if the main loop
+                                needs to stop.
+        :param float sleep_time: how much time in second every loop waits.
+        :return: None
+        """
+        if interrupt_check():
+            logger.debug("detect voice return")
+            return
+
+        tc = type(detected_callback)
+        if tc is not list:
+            detected_callback = [detected_callback]
+        if len(detected_callback) == 1 and self.num_hotwords > 1:
+            detected_callback *= self.num_hotwords
+
+        assert self.num_hotwords == len(detected_callback), \
+            "Error: hotwords in your models (%d) do not match the number of " \
+            "callbacks (%d)" % (self.num_hotwords, len(detected_callback))
+
+        logger.debug("detecting...")
+
+        while True:
+            if interrupt_check():
+                logger.debug("detect voice break")
+                break
+            data = self.ring_buffer.get()
+            if len(data) == 0:
+                time.sleep(sleep_time)
+                continue
+
+            ans = self.detector.RunDetection(data)
+            if ans == -1:
+                logger.warning("Error initializing streams or reading audio data")
+            elif ans > 0:
+                message = "Keyword " + str(ans) + " detected at time: "
+                message += time.strftime("%Y-%m-%d %H:%M:%S",
+                                         time.localtime(time.time()))
+                logger.info(message)
+                callback = detected_callback[ans-1]
+                if callback is not None:
+                    callback()
+
+        logger.debug("finished.")
+
+    def terminate(self):
+        """
+        Terminate audio stream. Users cannot call start() again to detect.
+        :return: None
+        """
+        self.stream_in.stop_stream()
+        self.stream_in.close()
+        self.audio.terminate()
@@ -0,0 +1,143 @@
+# This file was automatically generated by SWIG (http://www.swig.org).
+# Version 3.0.7
+#
+# Do not make changes to this file unless you know what you are doing--modify
+# the SWIG interface file instead.
+
+
+
+
+
+from sys import version_info
+if version_info >= (2, 6, 0):
+    def swig_import_helper():
+        from os.path import dirname
+        import imp
+        fp = None
+        try:
+            fp, pathname, description = imp.find_module('_snowboydetect', [dirname(__file__)])
+        except ImportError:
+            import _snowboydetect
+            return _snowboydetect
+        if fp is not None:
+            try:
+                _mod = imp.load_module('_snowboydetect', fp, pathname, description)
+            finally:
+                fp.close()
+            return _mod
+    _snowboydetect = swig_import_helper()
+    del swig_import_helper
+else:
+    import _snowboydetect
+del version_info
+try:
+    _swig_property = property
+except NameError:
+    pass  # Python < 2.2 doesn't have 'property'.
+
+
+def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
+    if (name == "thisown"):
+        return self.this.own(value)
+    if (name == "this"):
+        if type(value).__name__ == 'SwigPyObject':
+            self.__dict__[name] = value
+            return
+    method = class_type.__swig_setmethods__.get(name, None)
+    if method:
+        return method(self, value)
+    if (not static):
+        if _newclass:
+            object.__setattr__(self, name, value)
+        else:
+            self.__dict__[name] = value
+    else:
+        raise AttributeError("You cannot add attributes to %s" % self)
+
+
+def _swig_setattr(self, class_type, name, value):
+    return _swig_setattr_nondynamic(self, class_type, name, value, 0)
+
+
+def _swig_getattr_nondynamic(self, class_type, name, static=1):
+    if (name == "thisown"):
+        return self.this.own()
+    method = class_type.__swig_getmethods__.get(name, None)
+    if method:
+        return method(self)
+    if (not static):
+        return object.__getattr__(self, name)
+    else:
+        raise AttributeError(name)
+
+def _swig_getattr(self, class_type, name):
+    return _swig_getattr_nondynamic(self, class_type, name, 0)
+
+
+def _swig_repr(self):
+    try:
+        strthis = "proxy of " + self.this.__repr__()
+    except:
+        strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+try:
+    _object = object
+    _newclass = 1
+except AttributeError:
+    class _object:
+        pass
+    _newclass = 0
+
+
+class SnowboyDetect(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, SnowboyDetect, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, SnowboyDetect, name)
+    __repr__ = _swig_repr
+
+    def __init__(self, resource_filename, model_str):
+        this = _snowboydetect.new_SnowboyDetect(resource_filename, model_str)
+        try:
+            self.this.append(this)
+        except:
+            self.this = this
+
+    def Reset(self):
+        return _snowboydetect.SnowboyDetect_Reset(self)
+
+    def RunDetection(self, *args):
+        return _snowboydetect.SnowboyDetect_RunDetection(self, *args)
+
+    def SetSensitivity(self, sensitivity_str):
+        return _snowboydetect.SnowboyDetect_SetSensitivity(self, sensitivity_str)
+
+    def GetSensitivity(self):
+        return _snowboydetect.SnowboyDetect_GetSensitivity(self)
+
+    def SetAudioGain(self, audio_gain):
+        return _snowboydetect.SnowboyDetect_SetAudioGain(self, audio_gain)
+
+    def UpdateModel(self):
+        return _snowboydetect.SnowboyDetect_UpdateModel(self)
+
+    def NumHotwords(self):
+        return _snowboydetect.SnowboyDetect_NumHotwords(self)
+
+    def SampleRate(self):
+        return _snowboydetect.SnowboyDetect_SampleRate(self)
+
+    def NumChannels(self):
+        return _snowboydetect.SnowboyDetect_NumChannels(self)
+
+    def BitsPerSample(self):
+        return _snowboydetect.SnowboyDetect_BitsPerSample(self)
+    __swig_destroy__ = _snowboydetect.delete_SnowboyDetect
+    __del__ = lambda self: None
+SnowboyDetect_swigregister = _snowboydetect.SnowboyDetect_swigregister
+SnowboyDetect_swigregister(SnowboyDetect)
+
+# This file is compatible with both classic and new-style classes.
+
+
@@ -0,0 +1 @@
+1.1.1