{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Long Audio VAD\n",
"\n",
"Let say you want to cut your realtime recording audio by using VAD, malaya-speech able to do that."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"This tutorial is available as an IPython notebook at [malaya-speech/example/long-audio-asr-torchaudio](https://github.com/huseinzol05/malaya-speech/tree/master/example/long-audio-asr-torchaudio).\n",
" \n",
"
\n",
"\n",
"This module is not language independent, so it not save to use on different languages. Pretrained models trained on hyperlocal languages.\n",
" \n",
"
\n",
"\n",
"This is an application of malaya-speech Pipeline, read more about malaya-speech Pipeline at [malaya-speech/example/pipeline](https://github.com/huseinzol05/malaya-speech/tree/master/example/pipeline).\n",
" \n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"`pyaudio` is not available, `malaya_speech.streaming.pyaudio` is not able to use.\n"
]
}
],
"source": [
"import malaya_speech\n",
"from malaya_speech import Pipeline\n",
"from malaya_speech.utils.astype import float_to_int"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Load VAD model\n",
"\n",
"We are going to use WebRTC VAD model, read more about VAD at https://malaya-speech.readthedocs.io/en/latest/load-vad.html"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"vad_model = malaya_speech.vad.webrtc()"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"p_vad = Pipeline()\n",
"pipeline = (\n",
" p_vad.map(lambda x: float_to_int(x, divide_max_abs=False))\n",
" .map(vad_model)\n",
")\n",
"p_vad.visualize()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Starting malaya-speech 1.4.0, streaming always returned a float32 array between -1 and +1 values."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Streaming interface\n",
"\n",
"```python\n",
"def stream(\n",
" src,\n",
" vad_model=None,\n",
" asr_model=None,\n",
" classification_model=None,\n",
" format=None,\n",
" option=None,\n",
" buffer_size: int = 4096,\n",
" sample_rate: int = 16000,\n",
" segment_length: int = 2560,\n",
" num_padding_frames: int = 20,\n",
" ratio: float = 0.75,\n",
" min_length: float = 0.1,\n",
" max_length: float = 10.0,\n",
" realtime_print: bool = True,\n",
" **kwargs,\n",
"):\n",
" \"\"\"\n",
" Stream an audio using torchaudio library.\n",
"\n",
" Parameters\n",
" ----------\n",
" vad_model: object, optional (default=None)\n",
" vad model / pipeline.\n",
" asr_model: object, optional (default=None)\n",
" ASR model / pipeline, will transcribe each subsamples realtime.\n",
" classification_model: object, optional (default=None)\n",
" classification pipeline, will classify each subsamples realtime.\n",
" format: str, optional (default=None)\n",
" Supported `format` for `torchaudio.io.StreamReader`,\n",
" https://pytorch.org/audio/stable/generated/torchaudio.io.StreamReader.html#torchaudio.io.StreamReader\n",
" option: dict, optional (default=None)\n",
" Supported `option` for `torchaudio.io.StreamReader`,\n",
" https://pytorch.org/audio/stable/generated/torchaudio.io.StreamReader.html#torchaudio.io.StreamReader\n",
" buffer_size: int, optional (default=4096)\n",
" Supported `buffer_size` for `torchaudio.io.StreamReader`, buffer size in byte. Used only when src is file-like object,\n",
" https://pytorch.org/audio/stable/generated/torchaudio.io.StreamReader.html#torchaudio.io.StreamReader\n",
" sample_rate: int, optional (default = 16000)\n",
" output sample rate.\n",
" segment_length: int, optional (default=2560)\n",
" usually derived from asr_model.segment_length * asr_model.hop_length,\n",
" size of audio chunks, actual size in term of second is `segment_length` / `sample_rate`.\n",
" num_padding_frames: int, optional (default=20)\n",
" size of acceptable padding frames for queue.\n",
" ratio: float, optional (default = 0.75)\n",
" if 75% of the queue is positive, assumed it is a voice activity.\n",
" min_length: float, optional (default=0.1)\n",
" minimum length (second) to accept a subsample.\n",
" max_length: float, optional (default=10.0)\n",
" maximum length (second) to accept a subsample.\n",
" realtime_print: bool, optional (default=True)\n",
" Will print results for ASR.\n",
" **kwargs: vector argument\n",
" vector argument pass to malaya_speech.streaming.pyaudio.Audio interface.\n",
"\n",
" Returns\n",
" -------\n",
" result : List[dict]\n",
" \"\"\"\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Start streaming"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/husein/.local/lib/python3.8/site-packages/torchaudio/io/_stream_reader.py:696: UserWarning: The number of buffered frames exceeded the buffer size. Dropping the old frames. To avoid this, you can set a higher buffer_chunk_size value. (Triggered internally at /root/project/torchaudio/csrc/ffmpeg/stream_reader/buffer.cpp:157.)\n",
" return self._be.process_packet(timeout, backoff)\n"
]
}
],
"source": [
"samples = malaya_speech.streaming.torchaudio.stream('speech/podcast/2x5%20Ep%2010.wav',\n",
" vad_model = p_vad, \n",
" segment_length = 320)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"23"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(samples)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"import IPython.display as ipd\n",
"import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'wav_data': array([ 0.0458374 , 0.04632568, 0.0489502 , ..., -0.03302002,\n",
" -0.03625488, -0.02584839], dtype=float32),\n",
" 'timestamp': datetime.datetime(2023, 2, 17, 0, 40, 4, 402398)}"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"samples[4]"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
" \n",
" "
],
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ipd.Audio(samples[4]['wav_data'], rate = 16000)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.10"
},
"varInspector": {
"cols": {
"lenName": 16,
"lenType": 16,
"lenVar": 40
},
"kernels_config": {
"python": {
"delete_cmd_postfix": "",
"delete_cmd_prefix": "del ",
"library": "var_list.py",
"varRefreshCmd": "print(var_dic_list())"
},
"r": {
"delete_cmd_postfix": ") ",
"delete_cmd_prefix": "rm(",
"library": "var_list.r",
"varRefreshCmd": "cat(var_dic_list()) "
}
},
"types_to_exclude": [
"module",
"function",
"builtin_function_or_method",
"instance",
"_Feature"
],
"window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 4
}