Add files using upload-large-folder tool

.gitattributes

@@ -1,59 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+NSNet-baseline/nsnet-baseline-dnschallenge.onnx filter=lfs diff=lfs merge=lfs -text
+docs/IS2020_noisesuppchallenge_base_paper.pdf filter=lfs diff=lfs merge=lfs -text

CODE_OF_CONDUCT.md

@@ -0,0 +1,9 @@
+# Microsoft Open Source Code of Conduct
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+
+Resources:
+
+- [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/)
+- [Microsoft Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+- Contact [[email protected]](mailto:[email protected]) with questions or concerns

LICENSE

@@ -0,0 +1,395 @@
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+	wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More_considerations
+     for the public: 
+	wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.

LICENSE-CODE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

NSNet-baseline/README.md

@@ -0,0 +1,37 @@
+# Noise Suppression Net (NSNet) baseline inference script
+
+* As a baseline for Interspeech 2020 Deep Noise Suppression challenge, we will use the recently developed SE method based on Recurrent Neural Network (RNN). For ease of reference, we will call this method as Noise Suppression Net (NSNet). The details about this method can be found in the [published paper](https://arxiv.org/pdf/2001.10601.pdf)
+* This method uses log power spectra as input to predict the enhancement gain per frame using a learning machine based on Gated Recurrent Units (GRU) and fully connected layers. Please refer to the paper for more details of the method.
+* NSNet is computationally efficient. It only takes 0.16ms to enhance a 20ms frame on an Intel quad core i5 machine using the ONNX run time v1.1 .
+
+## Prerequisites
+- Python 3.0 and above
+- pysoundfile (pip install pysoundfile)
+- onnxruntime (pip install onnxruntime)
+
+## Files:
+- nsnet_eval_local.py - Main script that calls onnx.py
+- onnx.py - Frame based inference
+- audiolib.py - Required audio libraries for inference
+- nsnet-baseline-dnschallenge.onnx - Trained NSNet ONNX model used for inference
+
+## Usage:
+From the NSNet-baseline directory, run nsnet_eval_local.py with the following required arguments:
+- --noisyspeechdir "Specify the path to noisy speech files that you want to enhance"
+- --enhanceddir "Specify the path to a directory where you want to store the enhanced clips"
+- --modelpath "Specify the path to the onnx model provided"
+
+Use default values for the rest. Run to enhance the clips.
+
+## Citation:
+The baseline NSNet noise suppression:<br />  
+```BibTex
+@INPROCEEDINGS{9054254, author={Y. {Xia} and S. {Braun} and C. K. A. {Reddy} 
+and H. {Dubey} and R. {Cutler} and I. {Tashev}}, 
+booktitle={ICASSP 2020 - 2020 IEEE International Conference on Acoustics, 
+Speech and Signal Processing (ICASSP)}, 
+title={Weighted Speech Distortion Losses for Neural-Network-Based Real-Time Speech Enhancement}, 
+year={2020}, volume={}, number={}, pages={871-875},}
+```
+
+Y. Xia, S. Braun, C. K. A. Reddy, H. Dubey, R. Cutler and I. Tashev, "Weighted Speech Distortion Losses for Neural-Network-Based Real-Time Speech Enhancement," ICASSP 2020 - 2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), Barcelona, Spain, 2020, pp. 871-875.

NSNet-baseline/audiolib.py

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+"""
+Functions for audio featurization.
+"""
+
+import os
+import math
+import logging
+
+import numpy as np
+import soundfile as sf
+import librosa
+
+SIGMA_EPS = 1e-12
+
+
+def stft(frame, _sr, wind, _hop, nfft, synth=False, zphase=False):
+    if not zphase:
+        return np.fft.rfft(frame, n=nfft)
+    fsize = len(wind)
+    woff = (fsize - (fsize % 2)) // 2
+    zp = np.zeros(nfft - fsize)
+    return np.fft.rfft(np.concatenate((frame[woff:], zp, frame[:woff])))
+
+
+def istft(frame, _sr, wind, nfft, zphase=False):
+    frame = np.fft.irfft(frame, nfft)
+    if zphase:
+        fsize = len(wind)
+        frame = np.roll(frame, (fsize - (fsize % 2)) // 2)[:fsize]
+    return frame
+
+
+def onlineMVN_perframe(
+        frame_feature, frame_counter, mu, sigmasquare,
+        frameshift=0.01, tauFeat=3., tauFeatInit=0.1, t_init=0.1):
+    """Online mean and variance normalization (per frequency)"""
+
+    n_init_frames = math.ceil(t_init / frameshift)
+    alpha_feat_init = math.exp(-frameshift / tauFeatInit)
+    alpha_feat = math.exp(-frameshift / tauFeat)
+
+    if frame_counter < n_init_frames:
+        alpha = alpha_feat_init
+    else:
+        alpha = alpha_feat
+
+    mu = alpha * mu + (1 - alpha) * frame_feature
+    sigmasquare = alpha * sigmasquare + (1 - alpha) * frame_feature**2
+    sigma = np.sqrt(np.maximum(sigmasquare - mu**2, SIGMA_EPS)) # limit for sqrt
+    norm_feature = (frame_feature - mu) / sigma
+    frame_counter += 1
+
+    return norm_feature, mu, sigmasquare, frame_counter
+
+
+def magphasor(complexspec):
+    """Decompose a complex spectrogram into magnitude and unit phasor.
+    m, p = magphasor(c) such that c == m * p.
+    """
+    mspec = np.abs(complexspec)
+    pspec = np.empty_like(complexspec)
+    zero_mag = mspec == 0.  # fix zero-magnitude
+    pspec[zero_mag] = 1.
+    pspec[~zero_mag] = complexspec[~zero_mag] / mspec[~zero_mag]
+    return mspec, pspec
+
+
+def logpow(sig, floor=-30.):
+    """Compute log power of complex spectrum.
+
+    Floor any -`np.inf` value to (nonzero minimum + `floor`) dB.
+    If all values are 0s, floor all values to -80 dB.
+    """
+    log10e = np.log10(np.e)
+    pspec = sig.real**2 + sig.imag**2
+    zeros = pspec == 0
+    logp = np.empty_like(pspec)
+    if np.any(~zeros):
+        logp[~zeros] = np.log(pspec[~zeros])
+        logp[zeros] = np.log(pspec[~zeros].min()) + floor / 10 / log10e
+    else:
+        logp.fill(-80 / 10 / log10e)
+
+    return logp
+
+
+def hamming(wsize, hop=None):
+    "Compute the Hamming window"
+
+    if hop is None:
+        return np.hamming(wsize)
+
+    # For perfect OLA reconstruction in time
+    if wsize % 2:  # Fix endpoint problem for odd-size window
+        wind = np.hamming(wsize)
+        wind[0] /= 2.
+        wind[-1] /= 2.
+    else:  # even-size window
+        wind = np.hamming(wsize + 1)
+        wind = wind[:-1]
+
+    assert tnorm(wind, hop), \
+        "[wsize:{}, hop:{}] violates COLA in time.".format(wsize, hop)
+
+    return wind
+
+
+def tnorm(wind, hop):
+    amp = tcola(wind, hop)
+    if amp is None:
+        return False
+    wind /= amp
+    return True
+
+
+def tcola(wind, _hop):
+    wsize = len(wind)
+    hsize = 160
+    buff = wind.copy()  # holds OLA buffer and account for time=0
+    for wi in range(hsize, wsize, hsize):  # window moving forward
+        wj = wi + wsize
+        buff[wi:] += wind[:wsize - wi]
+    for wj in range(wsize - hsize, 0, -hsize):  # window moving backward
+        wi = wj - wsize
+        buff[:wj] += wind[wsize - wj:]
+
+    if np.allclose(buff, buff[0]):
+        return buff[0]
+
+    return None
+
+
+def audioread(path, sr=None, start=0, stop=None, mono=True, norm=False):
+
+    path = os.path.abspath(path)
+    if not os.path.exists(path):
+        logging.error('File does not exist: %s', path)
+        raise ValueError("[{}] does not exist!".format(path))
+
+    try:
+        x, xsr = sf.read(path, start=start, stop=stop)
+    except RuntimeError:  # fix for sph pcm-embedded shortened v2
+        logging.warning('Audio type not supported for file %s. Trying sph2pipe...', path)
+
+    if len(x.shape) == 1:  # mono
+        if sr and xsr != sr:
+            print("Resampling to sampling rate:", sr)
+            x = librosa.resample(x, xsr, sr)
+            xsr = sr
+        if norm:
+            print("Normalization input data")
+            x /= np.max(np.abs(x))
+        return x, xsr
+
+    # multi-channel
+    x = x.T
+    if sr and xsr != sr:
+        x = librosa.resample(x, xsr, sr, axis=1)
+        xsr = sr
+    if mono:
+        x = x.sum(axis=0) / x.shape[0]
+    if norm:
+        for chan in range(x.shape[0]):
+            x[chan, :] /= np.max(np.abs(x[chan, :]))
+
+    return x, xsr
+
+
+def audiowrite(data, sr, outpath, norm=False):
+
+    logging.debug("Writing to: %s", outpath)
+
+    if np.max(np.abs(data)) == 0: # in case all entries are 0s
+        logging.warning("All-zero output! Something is not quite right,"
+                        " check your input audio clip and model.")
+
+    outpath = os.path.abspath(outpath)
+    outdir = os.path.dirname(outpath)
+
+    if not os.path.exists(outdir):
+        os.makedirs(outdir)
+
+    sf.write(outpath, data, sr)

NSNet-baseline/nsnet-baseline-dnschallenge.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:983adad31c7b42534f84253d43fafce44d755cfab70d9c5822e8f737aee37169
+size 5040632

NSNet-baseline/nsnet_eval_local.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+Runnable script to invoke
+noise_suppression.nsnet.inference.onnx
+"""
+
+import os
+import glob
+import logging
+import pathlib
+import concurrent.futures
+import argparse
+import onnx as ns_onnx
+
+# pylint: disable=too-few-public-methods
+class Worker:
+    """
+    Delayed constructor of NSNetInference to make sure each
+    multiprocessing worker has its own instance of the ONNX model.
+    """
+    nsnet = None
+
+    def __init__(self, *args):
+        self.args = args
+
+    def __call__(self, fname):
+        if Worker.nsnet is None:
+            # pylint: disable=no-value-for-parameter
+            Worker.nsnet = ns_onnx.NSNetInference(*self.args)
+        logging.debug("NSNet/ONNX: process file %s", fname)
+        Worker.nsnet(fname)
+
+
+def _main():
+
+    parser = argparse.ArgumentParser(description='NSNet Noise Suppressor inference', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument('--noisyspeechdir', required=True, help="Input directory with noisy WAV files")
+    parser.add_argument('--enhanceddir', required=True, help="Output directory to save enhanced WAV files")
+    parser.add_argument('--modelpath', required=True, help="ONNX model to use for inference")
+    parser.add_argument('--window_length', type=float, default=0.02)
+    parser.add_argument('--hopfraction', type=float, default=0.5)
+    parser.add_argument('--dft_size', type=int, default=512)
+    parser.add_argument('--sampling_rate', type=int, default=16000)
+    parser.add_argument('--spectral_floor', type=float, default=-120.0)
+    parser.add_argument('--timesignal_floor', type=float, default=1e-12)
+    parser.add_argument('--audioformat', default="*.wav")
+    parser.add_argument('--num_workers', type=int, default=4,
+               help="Number of OS processes to run in parallel")
+    parser.add_argument('--chunksize', type=int, default=1,
+               help="Number of files per worker to process in one batch")
+
+    args = parser.parse_args()
+
+    logging.info("NSNet inference args: %s", args)
+
+    input_filelist = glob.glob(os.path.join(args.noisyspeechdir, args.audioformat))
+    pathlib.Path(args.enhanceddir).mkdir(parents=True, exist_ok=True)
+
+    worker = Worker(args.modelpath, args.window_length, args.hopfraction,
+                    args.dft_size, args.sampling_rate, args.enhanceddir)
+
+    logging.debug("NSNet local workers start with %d input files", len(input_filelist))
+
+#    with concurrent.futures.ThreadPoolExecutor(max_workers=args.num_workers) as executor:
+#        executor.map(worker, input_filelist, chunksize=args.chunksize)
+    for fname in input_filelist:
+        worker(fname)
+        
+    logging.info("NSNet local workers complete")
+
+
+logging.basicConfig(
+    format='%(asctime)s %(levelname)s %(message)s',
+    level=logging.DEBUG)  # Use logging.WARNING in prod
+
+if __name__ == '__main__':
+    _main()

NSNet-baseline/onnx.py

@@ -0,0 +1,108 @@
+"""
+Run NSNet inference using onnxruntime.
+"""
+
+import os
+import math
+import logging
+
+import numpy as np
+import soundfile as sf
+import onnxruntime
+
+import audiolib
+
+
+# pylint: disable=too-few-public-methods
+class NSNetInference:
+    "Apply NSNet ONNX model to WAV files"
+
+    def __init__(self, model_path, window_length, hop_fraction,
+                 dft_size, sampling_rate, output_dir=None,
+                 spectral_floor=-120.0, timesignal_floor=1e-12):
+        self.hop_fraction = hop_fraction
+        self.dft_size = dft_size
+        self.sampling_rate = sampling_rate
+        self.output_dir = output_dir
+        self.spectral_floor = spectral_floor
+        self.timesignal_floor = timesignal_floor
+        self.framesize = int(window_length * sampling_rate)
+        self.wind = audiolib.hamming(self.framesize, hop=hop_fraction)
+        self.model = onnxruntime.InferenceSession(model_path)
+
+    # pylint: disable=too-many-locals,invalid-name
+    def __call__(self, noisy_speech_filename, output_dir=None):
+        "Apply NSNet model to one file and produce an output file with clean speech."
+
+        enhanced_filename = os.path.join(output_dir or self.output_dir,
+                                         os.path.basename(noisy_speech_filename))
+
+        logging.info("NSNet inference: %s", noisy_speech_filename)
+        sig, sample_rate = sf.read(noisy_speech_filename)
+
+        ssize = len(sig)
+        print('ssize:', ssize)
+        fsize = len(self.wind)
+        hsize = int(self.hop_fraction * self.framesize)
+
+        sstart = hsize - fsize
+        print('sstart:', sstart)
+        send = ssize
+        nframe = math.ceil((send - sstart) / hsize)
+        zpleft = -sstart
+        zpright = (nframe - 1) * hsize + fsize - zpleft - ssize
+
+        if zpleft > 0 or zpright > 0:
+            sigpad = np.zeros(ssize + zpleft + zpright)
+            sigpad[zpleft:len(sigpad)-zpright] = sig
+        else:
+            sigpad = sig
+
+        sout = np.zeros(nframe * hsize)
+        x_old = np.zeros(hsize)
+
+        model_input_names = [inp.name for inp in self.model.get_inputs()]
+        model_inputs = {
+            inp.name: np.zeros(
+                [dim if isinstance(dim, int) else 1 for dim in inp.shape],
+                dtype=np.float32)
+            for inp in self.model.get_inputs()[1:]}
+
+        mu = None
+        sigmasquare = None
+        frame_count = 0
+
+        for frame_sampleindex in range(0, nframe * hsize, hsize):
+
+            # second frame starts from mid-of first frame and goes until frame-size
+            sigpadframe = sigpad[frame_sampleindex:frame_sampleindex + fsize] * self.wind
+
+            xmag, xphs = audiolib.magphasor(audiolib.stft(
+                sigpadframe, self.sampling_rate, self.wind,
+                self.hop_fraction, self.dft_size, synth=True, zphase=False))
+
+            feat = audiolib.logpow(xmag, floor=self.spectral_floor)
+
+            if frame_sampleindex == 0:
+                mu = feat
+                sigmasquare = feat**2
+
+            norm_feat, mu, sigmasquare, frame_count = audiolib.onlineMVN_perframe(
+                feat, frame_counter=frame_count, mu=mu, sigmasquare=sigmasquare,
+                frameshift=0.01, tauFeat=3., tauFeatInit=0.1, t_init=0.1)
+
+            norm_feat = norm_feat[np.newaxis, np.newaxis, :]
+
+            model_inputs['input'] = np.float32(norm_feat)
+            model_outputs = self.model.run(None, model_inputs)
+            model_inputs = dict(zip(model_input_names, model_outputs))
+
+            mask = model_outputs[0].squeeze()
+            x_enh = audiolib.istft(
+                (xmag * mask) * xphs, sample_rate, self.wind, self.dft_size, zphase=False)
+            
+            sout[frame_sampleindex:frame_sampleindex + hsize] = x_old + x_enh[0:hsize]
+            x_old = x_enh[hsize:fsize]
+
+        xfinal = sout
+        audiolib.audiowrite(xfinal, sample_rate, enhanced_filename, norm=False)

README.md

@@ -1,3 +1,130 @@
----
-license: mit
----
+# Deep Noise Suppression (DNS) Challenge - Interspeech 2020
+
+This repository contains the datasets and scripts required for the DNS challenge. For more details about the challenge, please visit https://dns-challenge.azurewebsites.net/ and refer to our [paper](https://arxiv.org/ftp/arxiv/papers/2001/2001.08662.pdf).
+
+## Repo details:
+* The **datasets** directory contains the clean speech and noise clips.
+* The **NSNet-baseline** directory contains the inference scripts and the ONNX model for the baseline Speech Enhancer called **Noise Suppression Net (NSNet)** 
+* **noisyspeech_synthesizer_singleprocess.py** - is used to synthesize noisy-clean speech pairs for training purposes.
+* **noisyspeech_synthesizer.cfg** - is the configuration file used to synthesize the data. Users are required to accurately specify different parameters.
+* **audiolib.py** - contains modules required to synthesize datasets
+* **utils.py** - contains some utility functions required to synthesize the data
+* **unit_tests_synthesizer.py** - contains the unit tests to ensure sanity of the data
+
+## Prerequisites
+- Python 3.0 and above
+- Soundfile (pip install pysoundfile), librosa
+
+## Usage:
+1. Install librosa 
+```
+pip install librosa
+```
+2. Install Git Large File Storage for faster download of the datasets.
+```
+git lfs install
+git lfs track "*.wav"
+git add .gitattributes
+```
+3. Clone the repository. 
+```
+git clone https://github.com/microsoft/DNS-Challenge DNS-Challenge
+```
+4. Edit **noisyspeech_synthesizer.cfg** to include the paths to clean speech and noise directories. Also, specify the paths to the destination directories and store logs.
+5. Create dataset 
+```
+python noisyspeech_synthesizer_multiprocessing.py
+```
+
+## Citation:
+For the datasets and the DNS challenge:<br />  
+
+```BibTex
+@article{reddy2020interspeech,
+  title={The INTERSPEECH 2020 Deep Noise Suppression Challenge: Datasets, Subjective Testing Framework, and Challenge Results},
+  author={Reddy, Chandan KA and Gopal, Vishak and Cutler, Ross and Beyrami, Ebrahim and Cheng, Roger and Dubey, Harishchandra and Matusevych, Sergiy and Aichner, Robert and Aazami, Ashkan and Braun, Sebastian and others},
+  journal={arXiv preprint arXiv:2005.13981},
+  year={2020}
+}
+```
+
+The baseline NSNet noise suppression:<br />  
+```BibTex
+@INPROCEEDINGS{9054254, author={Y. {Xia} and S. {Braun} and C. K. A. {Reddy} 
+and H. {Dubey} and R. {Cutler} and I. {Tashev}}, 
+booktitle={ICASSP 2020 - 2020 IEEE International Conference on Acoustics, 
+Speech and Signal Processing (ICASSP)}, 
+title={Weighted Speech Distortion Losses for Neural-Network-Based Real-Time Speech Enhancement}, 
+year={2020}, volume={}, number={}, pages={871-875},}
+```
+
+
+# Contributing
+
+This project welcomes contributions and suggestions.  Most contributions require you to agree to a
+Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
+the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.
+
+When you submit a pull request, a CLA bot will automatically determine whether you need to provide
+a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
+provided by the bot. You will only need to do this once across all repos using our CLA.
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
+contact [[email protected]](mailto:[email protected]) with any additional questions or comments.
+
+# Legal Notices
+
+Microsoft and any contributors grant you a license to the Microsoft documentation and other content
+in this repository under the [Creative Commons Attribution 4.0 International Public License](https://creativecommons.org/licenses/by/4.0/legalcode),
+see the [LICENSE](LICENSE) file, and grant you a license to any code in the repository under the [MIT License](https://opensource.org/licenses/MIT), see the
+[LICENSE-CODE](LICENSE-CODE) file.
+
+Microsoft, Windows, Microsoft Azure and/or other Microsoft products and services referenced in the documentation
+may be either trademarks or registered trademarks of Microsoft in the United States and/or other countries.
+The licenses for this project do not grant you rights to use any Microsoft names, logos, or trademarks.
+Microsoft's general trademark guidelines can be found at http://go.microsoft.com/fwlink/?LinkID=254653.
+
+Privacy information can be found at https://privacy.microsoft.com/en-us/
+
+Microsoft and any contributors reserve all other rights, whether under their respective copyrights, patents,
+or trademarks, whether by implication, estoppel or otherwise.
+
+
+## Dataset licenses
+MICROSOFT PROVIDES THE DATASETS ON AN "AS IS" BASIS. MICROSOFT MAKES NO WARRANTIES, EXPRESS OR IMPLIED, GUARANTEES OR CONDITIONS WITH RESPECT TO YOUR USE OF THE DATASETS. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAW, MICROSOFT DISCLAIMS ALL LIABILITY FOR ANY DAMAGES OR LOSSES, INLCUDING DIRECT, CONSEQUENTIAL, SPECIAL, INDIRECT, INCIDENTAL OR PUNITIVE, RESULTING FROM YOUR USE OF THE DATASETS.
+
+The datasets are provided under the original terms that Microsoft received such datasets. See below for more information about each dataset.
+
+The datasets used in this project are licensed as follows:
+1. Clean speech: 
+* https://librivox.org/; License: https://librivox.org/pages/public-domain/
+* PTDB-TUG: Pitch Tracking Database from Graz University of Technology https://www.spsc.tugraz.at/databases-and-tools/ptdb-tug-pitch-tracking-database-from-graz-university-of-technology.html; License: http://opendatacommons.org/licenses/odbl/1.0/ 
+* Edinburgh 56 speaker dataset: https://datashare.is.ed.ac.uk/handle/10283/2791; License: https://datashare.is.ed.ac.uk/bitstream/handle/10283/2791/license_text?sequence=11&isAllowed=y 
+2. Noise:
+* Audioset: https://research.google.com/audioset/index.html; License: https://creativecommons.org/licenses/by/4.0/
+* Freesound: https://freesound.org/ Only files with CC0 licenses were selected; License: https://creativecommons.org/publicdomain/zero/1.0/
+* Demand: https://zenodo.org/record/1227121#.XRKKxYhKiUk; License: https://creativecommons.org/licenses/by-sa/3.0/deed.en_CA
+
+## Code license
+MIT License
+
+Copyright (c) Microsoft Corporation.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE

SECURITY.md

@@ -0,0 +1,41 @@
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.3 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets Microsoft's [Microsoft's definition of a security vulnerability](https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)) of a security vulnerability, please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
+
+If you prefer to submit without logging in, send email to [[email protected]](mailto:[email protected]).  If possible, encrypt your message with our PGP key; please download it from the the [Microsoft Security Response Center PGP Key page](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc).
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

audiolib.py

@@ -0,0 +1,297 @@
+# -*- coding: utf-8 -*-
+"""
+@author: chkarada
+"""
+import os
+import numpy as np
+import soundfile as sf
+import subprocess
+import glob
+import librosa
+import random
+import tempfile
+
+EPS = np.finfo(float).eps
+np.random.seed(0)
+
+def is_clipped(audio, clipping_threshold=0.99):
+    return any(abs(audio) > clipping_threshold)
+
+def normalize(audio, target_level=-25):
+    '''Normalize the signal to the target level'''
+    rms = (audio ** 2).mean() ** 0.5
+    scalar = 10 ** (target_level / 20) / (rms+EPS)
+    audio = audio * scalar
+    return audio
+
+def normalize_segmental_rms(audio, rms, target_level=-25):
+    '''Normalize the signal to the target level
+    based on segmental RMS'''
+    scalar = 10 ** (target_level / 20) / (rms+EPS)
+    audio = audio * scalar
+    return audio
+
+def audioread(path, norm=False, start=0, stop=None, target_level=-25):
+    '''Function to read audio'''
+
+    path = os.path.abspath(path)
+    if not os.path.exists(path):
+        raise ValueError("[{}] does not exist!".format(path))
+    try:
+        audio, sample_rate = sf.read(path, start=start, stop=stop)
+    except RuntimeError:  # fix for sph pcm-embedded shortened v2
+        print('WARNING: Audio type not supported')
+
+    if len(audio.shape) == 1:  # mono
+        if norm:
+            rms = (audio ** 2).mean() ** 0.5
+            scalar = 10 ** (target_level / 20) / (rms+EPS)
+            audio = audio * scalar
+    else:  # multi-channel
+        audio = audio.T
+        audio = audio.sum(axis=0)/audio.shape[0]
+        if norm:
+            audio = normalize(audio, target_level)
+
+    return audio, sample_rate
+
+
+def audiowrite(destpath, audio, sample_rate=16000, norm=False, target_level=-25, \
+                clipping_threshold=0.99, clip_test=False):
+    '''Function to write audio'''
+
+    if clip_test:
+        if is_clipped(audio, clipping_threshold=clipping_threshold):
+            raise ValueError("Clipping detected in audiowrite()! " + \
+                            destpath + " file not written to disk.")
+
+    if norm:
+        audio = normalize(audio, target_level)
+        max_amp = max(abs(audio))
+        if max_amp >= clipping_threshold:
+            audio = audio/max_amp * (clipping_threshold-EPS)
+
+    destpath = os.path.abspath(destpath)
+    destdir = os.path.dirname(destpath)
+
+    if not os.path.exists(destdir):
+        os.makedirs(destdir)
+
+    sf.write(destpath, audio, sample_rate)
+    return
+
+
+def add_reverb(sasxExe, input_wav, filter_file, output_wav):
+    ''' Function to add reverb'''
+    command_sasx_apply_reverb = "{0} -r {1} \
+        -f {2} -o {3}".format(sasxExe, input_wav, filter_file, output_wav)
+                                                               
+    subprocess.call(command_sasx_apply_reverb)
+    return output_wav
+
+
+def add_clipping(audio, max_thresh_perc=0.8):
+    '''Function to add clipping'''
+    threshold = max(abs(audio))*max_thresh_perc
+    audioclipped = np.clip(audio, -threshold, threshold)
+    return audioclipped
+
+
+def adsp_filter(Adspvqe, nearEndInput, nearEndOutput, farEndInput):
+
+    command_adsp_clean = "{0} --breakOnErrors 0 --sampleRate 16000 --useEchoCancellation 0 \
+                    --operatingMode 2 --useDigitalAgcNearend 0 --useDigitalAgcFarend 0 \
+                    --useVirtualAGC 0 --useComfortNoiseGenerator 0 --useAnalogAutomaticGainControl 0 \
+                    --useNoiseReduction 0 --loopbackInputFile {1} --farEndInputFile {2} \
+                    --nearEndInputFile {3} --nearEndOutputFile {4}".format(Adspvqe,
+                                farEndInput, farEndInput, nearEndInput, nearEndOutput)
+    subprocess.call(command_adsp_clean)
+
+
+def snr_mixer(params, clean, noise, snr, target_level=-25, clipping_threshold=0.99):
+    '''Function to mix clean speech and noise at various SNR levels'''
+    cfg = params['cfg']
+    if len(clean) > len(noise):
+        noise = np.append(noise, np.zeros(len(clean)-len(noise)))
+    else:
+        clean = np.append(clean, np.zeros(len(noise)-len(clean)))
+
+    # Normalizing to -25 dB FS
+    clean = clean/(max(abs(clean))+EPS)
+    clean = normalize(clean, target_level)
+    rmsclean = (clean**2).mean()**0.5
+
+    noise = noise/(max(abs(noise))+EPS)
+    noise = normalize(noise, target_level)
+    rmsnoise = (noise**2).mean()**0.5
+
+    # Set the noise level for a given SNR
+    noisescalar = rmsclean / (10**(snr/20)) / (rmsnoise+EPS)
+    noisenewlevel = noise * noisescalar
+
+    # Mix noise and clean speech
+    noisyspeech = clean + noisenewlevel
+    
+    # Randomly select RMS value between -15 dBFS and -35 dBFS and normalize noisyspeech with that value
+    # There is a chance of clipping that might happen with very less probability, which is not a major issue. 
+    noisy_rms_level = np.random.randint(params['target_level_lower'], params['target_level_upper'])
+    rmsnoisy = (noisyspeech**2).mean()**0.5
+    scalarnoisy = 10 ** (noisy_rms_level / 20) / (rmsnoisy+EPS)
+    noisyspeech = noisyspeech * scalarnoisy
+    clean = clean * scalarnoisy
+    noisenewlevel = noisenewlevel * scalarnoisy
+
+    # Final check to see if there are any amplitudes exceeding +/- 1. If so, normalize all the signals accordingly
+    if is_clipped(noisyspeech):
+        noisyspeech_maxamplevel = max(abs(noisyspeech))/(clipping_threshold-EPS)
+        noisyspeech = noisyspeech/noisyspeech_maxamplevel
+        clean = clean/noisyspeech_maxamplevel
+        noisenewlevel = noisenewlevel/noisyspeech_maxamplevel
+        noisy_rms_level = int(20*np.log10(scalarnoisy/noisyspeech_maxamplevel*(rmsnoisy+EPS)))
+
+    return clean, noisenewlevel, noisyspeech, noisy_rms_level
+
+
+def segmental_snr_mixer(params, clean, noise, snr, target_level=-25, clipping_threshold=0.99):
+    '''Function to mix clean speech and noise at various segmental SNR levels'''
+    cfg = params['cfg']
+    if len(clean) > len(noise):
+        noise = np.append(noise, np.zeros(len(clean)-len(noise)))
+    else:
+        clean = np.append(clean, np.zeros(len(noise)-len(clean)))
+    clean = clean/(max(abs(clean))+EPS)
+    noise = noise/(max(abs(noise))+EPS)
+    rmsclean, rmsnoise = active_rms(clean=clean, noise=noise)
+    clean = normalize_segmental_rms(clean, rms=rmsclean, target_level=target_level)
+    noise = normalize_segmental_rms(noise, rms=rmsnoise, target_level=target_level)
+    # Set the noise level for a given SNR
+    noisescalar = rmsclean / (10**(snr/20)) / (rmsnoise+EPS)
+    noisenewlevel = noise * noisescalar
+
+    # Mix noise and clean speech
+    noisyspeech = clean + noisenewlevel
+    # Randomly select RMS value between -15 dBFS and -35 dBFS and normalize noisyspeech with that value
+    # There is a chance of clipping that might happen with very less probability, which is not a major issue. 
+    noisy_rms_level = np.random.randint(params['target_level_lower'], params['target_level_upper'])
+    rmsnoisy = (noisyspeech**2).mean()**0.5
+    scalarnoisy = 10 ** (noisy_rms_level / 20) / (rmsnoisy+EPS)
+    noisyspeech = noisyspeech * scalarnoisy
+    clean = clean * scalarnoisy
+    noisenewlevel = noisenewlevel * scalarnoisy
+    # Final check to see if there are any amplitudes exceeding +/- 1. If so, normalize all the signals accordingly
+    if is_clipped(noisyspeech):
+        noisyspeech_maxamplevel = max(abs(noisyspeech))/(clipping_threshold-EPS)
+        noisyspeech = noisyspeech/noisyspeech_maxamplevel
+        clean = clean/noisyspeech_maxamplevel
+        noisenewlevel = noisenewlevel/noisyspeech_maxamplevel
+        noisy_rms_level = int(20*np.log10(scalarnoisy/noisyspeech_maxamplevel*(rmsnoisy+EPS)))
+
+    return clean, noisenewlevel, noisyspeech, noisy_rms_level
+    
+
+def active_rms(clean, noise, fs=16000, energy_thresh=-50):
+    '''Returns the clean and noise RMS of the noise calculated only in the active portions'''
+    window_size = 100 # in ms
+    window_samples = int(fs*window_size/1000)
+    sample_start = 0
+    noise_active_segs = []
+    clean_active_segs = []
+
+    while sample_start < len(noise):
+        sample_end = min(sample_start + window_samples, len(noise))
+        noise_win = noise[sample_start:sample_end]
+        clean_win = clean[sample_start:sample_end]
+        noise_seg_rms = 20*np.log10((noise_win**2).mean()+EPS)
+        # Considering frames with energy
+        if noise_seg_rms > energy_thresh:
+            noise_active_segs = np.append(noise_active_segs, noise_win)
+            clean_active_segs = np.append(clean_active_segs, clean_win)
+        sample_start += window_samples
+
+    if len(noise_active_segs)!=0:
+        noise_rms = (noise_active_segs**2).mean()**0.5
+    else:
+        noise_rms = EPS
+        
+    if len(clean_active_segs)!=0:
+        clean_rms = (clean_active_segs**2).mean()**0.5
+    else:
+        clean_rms = EPS
+
+    return clean_rms, noise_rms
+
+
+def activitydetector(audio, fs=16000, energy_thresh=0.13, target_level=-25):
+    '''Return the percentage of the time the audio signal is above an energy threshold'''
+
+    audio = normalize(audio, target_level)
+    window_size = 50 # in ms
+    window_samples = int(fs*window_size/1000)
+    sample_start = 0
+    cnt = 0
+    prev_energy_prob = 0
+    active_frames = 0
+
+    a = -1
+    b = 0.2
+    alpha_rel = 0.05
+    alpha_att = 0.8
+
+    while sample_start < len(audio):
+        sample_end = min(sample_start + window_samples, len(audio))
+        audio_win = audio[sample_start:sample_end]
+        frame_rms = 20*np.log10(sum(audio_win**2)+EPS)
+        frame_energy_prob = 1./(1+np.exp(-(a+b*frame_rms)))
+
+        if frame_energy_prob > prev_energy_prob:
+            smoothed_energy_prob = frame_energy_prob*alpha_att + prev_energy_prob*(1-alpha_att)
+        else:
+            smoothed_energy_prob = frame_energy_prob*alpha_rel + prev_energy_prob*(1-alpha_rel)
+
+        if smoothed_energy_prob > energy_thresh:
+            active_frames += 1
+        prev_energy_prob = frame_energy_prob
+        sample_start += window_samples
+        cnt += 1
+
+    perc_active = active_frames/cnt
+    return perc_active
+
+
+def resampler(input_dir, target_sr=16000, ext='*.wav'):
+    '''Resamples the audio files in input_dir to target_sr'''
+    files = glob.glob(f"{input_dir}/"+ext)
+    for pathname in files:
+        print(pathname)
+        try:
+            audio, fs = audioread(pathname)
+            audio_resampled = librosa.core.resample(audio, fs, target_sr)
+            audiowrite(pathname, audio_resampled, target_sr)
+        except:
+            continue
+
+
+def audio_segmenter(input_dir, dest_dir, segment_len=10, ext='*.wav'):
+    '''Segments the audio clips in dir to segment_len in secs'''
+    files = glob.glob(f"{input_dir}/"+ext)
+    for i in range(len(files)):
+        audio, fs = audioread(files[i])
+        
+        if len(audio) > (segment_len*fs) and len(audio)%(segment_len*fs) != 0:
+            audio = np.append(audio, audio[0 : segment_len*fs - (len(audio)%(segment_len*fs))]) 
+        if len(audio) < (segment_len*fs):
+            while len(audio) < (segment_len*fs):
+                audio = np.append(audio, audio)
+            audio = audio[:segment_len*fs]
+        
+        num_segments = int(len(audio)/(segment_len*fs))
+        audio_segments = np.split(audio, num_segments)
+
+        basefilename = os.path.basename(files[i])
+        basename, ext = os.path.splitext(basefilename)
+
+        for j in range(len(audio_segments)):
+            newname = basename+'_'+str(j)+ext
+            destpath = os.path.join(dest_dir,newname)
+            audiowrite(destpath, audio_segments[j], fs)
+

datasets/Readme.md

@@ -0,0 +1,23 @@
+# Datasets for training
+Datasets will be downloaded when you clone the repository. Run **git lfs install** for faster download.   
+## Clean Speech
+* The clean speech dataset is derived from the public audio books dataset called Librivox.
+* Librivox has recordings of volunteers reading over 10,000 public domain audio books in various languages, with majority of which are in English. In total, there are 11,350 speakers.
+* A section of these recordings is of excellent quality, meaning that the speech was recorded using good quality microphones in a silent and less reverberant environments.
+* But there are many audio recordings that are of poor speech quality with speech distortion, background noise and reverberation. Hence, it is important to filter the data based on speech quality. 
+* We used the online subjective test framework ITU-T P.808 to sort the book chapters by subjective quality.
+* The audio chapters in Librivox are of variable length ranging from few seconds to several minutes.
+* We sampled 10 random clips from each book chapter, each 10 seconds in duration. For each clip we had 3 ratings, and the Mean Opinion Score (MOS) across the all clips was used as the book chapter MOS.
+* The upper quartile with respect to MOS was chosen as our clean speech dataset, which are top 25% of the clips with MOS as a metric.
+* The upper quartile comprised of audio chapters with 4.3 ≤ MOS ≤ 5. We removed clips from speakers with less than 15 minutes of speech. The resulting dataset has 500 hours of speech from 2150 speakers. 
+* All the filtered clips are then split into segments of 31 seconds. 
+
+## Noise
+* The noise clips were selected from Audioset and Freesound.
+* Audioset is a collection of about 2 million human-labeled 10s sound clips drawn from YouTube videos and belong to about 600 audio events.
+* Like the Librivox data, certain audio event classes are overrepresented. For example, there are over a million clips with audio classes music and speech and less than 200 clips for classes such as toothbrush, creak etc.
+* Approximately, 42% of the clips have single class, but the rest may have 2 to 15 labels. 
+* Hence, we developed a sampling approach to balance the dataset in such a way that each class has at least 500 clips.
+* We also used a speech activity detector (trained classifier) to remove the clips with any kind of speech activity. The reason is to avoid suppression of speech by the noise suppression model trained to suppress speech like noise.
+* The resulting dataset has about 150 audio classes and 60,000 clips. We also augmented an additional 10,000 noise clips downloaded from Freesound and DEMAND databases.
+* The chosen noise types are more relevant to VOIP applications.

datasets/blind_test_set/noreverb_fileid_0.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83d84826625d87e2b9fe3a9fa415784d980fd11f7478db4726c2a39d84d15c7c
+size 320044

datasets/blind_test_set/noreverb_fileid_1.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eedb91d82ecfaf483152e391537ee6ff0657b43fe44c24b7191ad88f3d0eca52
+size 320044

datasets/blind_test_set/noreverb_fileid_10.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfca25e122f507f4fbb8681277092f1e8a72633f869bf723a2a02573125563a7
+size 320044

datasets/blind_test_set/noreverb_fileid_100.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c29d04e43811a74cbc6f69e706b67855e7fe75217dffce929c296e6e404f1663
+size 320044

datasets/blind_test_set/noreverb_fileid_101.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04dc396b0db79e79a21e794be9414ab073811b29239e1526b17d307b9dac85ca
+size 320044

datasets/blind_test_set/noreverb_fileid_102.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25b66356250646d25f998479fd7f4d5c41debb969aac81c7572323dcc425e554
+size 320044

datasets/blind_test_set/noreverb_fileid_103.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a6a2c701f0219a7659da57774e6f7b7074cbd520917e8ffefcdea444c14d6ca
+size 320044

datasets/blind_test_set/noreverb_fileid_104.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afadfcb7ab91622f581a910f13bad96a9b8da48263109b31c5601bbdc0ade100
+size 320044

datasets/blind_test_set/noreverb_fileid_105.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8851c4e5cf5e06e9071cd68610d0ee7e4e3d892b1a724f4de02e0b199461394c
+size 320044

datasets/blind_test_set/noreverb_fileid_106.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66085325ae1e36e47a4f5d047ce6a8c2a1dff5123d35628af9e577b2ba8d6669
+size 320044

datasets/blind_test_set/noreverb_fileid_107.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2653ac97abdd771ee984fb254e68680004124709ca7a0565feaaecc6ddafe120
+size 320044

datasets/blind_test_set/noreverb_fileid_108.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6af66feaa9062c00c25354631fec314ae2db87ba0dc165289423881542254a71
+size 320044

datasets/blind_test_set/noreverb_fileid_109.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23f3f72ae2a2e31ebfcd12bc16bd0bf412d8747687b077518d212a53341d7441
+size 320044

datasets/blind_test_set/noreverb_fileid_11.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dea61dcdf1a76529afb475adea80235fcd0999b41aa10f4c573d81384180fa98
+size 320044

datasets/blind_test_set/noreverb_fileid_110.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe9aadd300caf3fbda574a7cab7d1a5699611d5fc12c725083218b43e3655b53
+size 320044

datasets/blind_test_set/noreverb_fileid_111.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5fbda6eac538df04cd22cb10b5dcc4c1285e550bfc5210084fa269ff778620e
+size 320044

datasets/blind_test_set/noreverb_fileid_112.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e8a6e2154a82900654ccfaaf29ae0cf6a095d2164dec659a2597fffa77a05a6
+size 320044

datasets/blind_test_set/noreverb_fileid_113.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c2c9403297bacda35e4d3267d3230cf34a55ab64a1f79e4fdb7f1e5451e3964
+size 320044

datasets/blind_test_set/noreverb_fileid_114.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce486cdfae524f572ded0abc679a437860497abd42edad354ade4722e1a9167d
+size 320044

datasets/blind_test_set/noreverb_fileid_116.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0ba6285afd75e4f14a993996c95ff3d2a05ef5cc75a17cc7840c9f647115cda
+size 320044

datasets/blind_test_set/noreverb_fileid_117.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c99f21493d377ed166761e7ad8e726b6751b1a02a915fada430425e2e8fbbd2b
+size 320044

datasets/blind_test_set/noreverb_fileid_119.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:092c39f0933d32b39fa3eaabdb663294e9ff6f3e71a7d2972f1d1c33cc2066bb
+size 320044

datasets/blind_test_set/noreverb_fileid_12.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:189dd84d451c69bea77d06daa6ce2b2b8d22b81673e752cfa36e258774ccebbe
+size 320044

datasets/blind_test_set/noreverb_fileid_121.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f56eade1afe283235e9f833d6d307810d4accbe833bedbad412c20945f5b5e32
+size 320044

datasets/blind_test_set/noreverb_fileid_128.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93622f6c06a3edfa577f4605daf1d9ae0d588c7f3aa78db964b121d74f274ab2
+size 320044

docs/IS2020_noisesuppchallenge_base_paper.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:626c1d27a6a7a89c33925c7af2d09b1c28b458502715ce38630ce0c49b1b4cf7
+size 552172

index.html

@@ -0,0 +1,243 @@
+<html>
+<head>
+  <title>Model comparison</title>
+  <script src="https://code.jquery.com/jquery-3.4.1.js"></script>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css">
+  <script src="filenamesAndModels.js"></script>
+</head>
+<style>
+.navbar {
+  overflow: hidden;
+  background-color: #333;
+  font-family: Arial, Helvetica, sans-serif;
+}
+
+.navbar a {
+  float: left;
+  font-size: 16px;
+  color: white;
+  text-align: center;
+  padding: 14px 16px;
+  text-decoration: none;
+}
+
+.dropdown {
+  float: center;
+  overflow: hidden;
+}
+
+.dropdown .dropbtn {
+  cursor: pointer;
+  font-size: 16px;  
+  border: none;
+  outline: none;
+  color: white;
+  padding: 14px 16px;
+  background-color: inherit;
+  font-family: inherit;
+  margin: 0;
+}
+
+.navbar a:hover, .dropdown:hover .dropbtn, .dropbtn:focus {
+  background-color: red;
+}
+
+.dropdown-content {
+  display: none;
+  position: absolute;
+  background-color: #f9f9f9;
+  min-width: 160px;
+  box-shadow: 0px 8px 16px 0px rgba(0,0,0,0.2);
+  z-index: 1;
+}
+
+.dropdown-content a {
+  float: none;
+  color: black;
+  padding: 12px 16px;
+  text-decoration: none;
+  display: block;
+  text-align: left;
+}
+
+.dropdown-content a:hover {
+  background-color: #ddd;
+}
+
+.show {
+  display: block;
+}
+</style>
+<script>
+
+
+
+var currentCount = 0;
+var currentFile = fileNames[currentCount];
+
+console.log(currentCount);
+console.log(currentFile);
+
+var modelsCount = baseUrls.length;
+var filesCount = fileNames.length;
+
+var modifiedFiles = []
+
+</script>
+<div class="navbar">
+  <button class="btn btn-primary btn-lg" onclick="loadMsRecordings()">MS Recordings</button>
+  <button class="btn btn-primary btn-lg" onclick="loadAudiosetRecordings()">Audioset Recordings</button>
+  <button class="btn btn-primary btn-lg" onclick="loadReverbRecordings()">Synthetic Reverb Recordings</button>
+  <button class="btn btn-primary btn-lg" onclick="loadNoReverbRecordings()">Synthetic NoReverb Recordings</button>
+  Enter the noise type to filter on<input type="text" name="noiseType"></input><button class="btn btn-info btn-lb" onclick="searchNoiseType()">Search noise type</button>
+</div>
+<div class="container">
+  <h2>Audio Clips</h2>
+	
+	<table class="table" id="table2">
+	  <tbody>
+		<tr><td>Index</td><td id="index"></td></tr>
+		<tr><td>Progress</td><td><div class="progress"><div class="progress-bar" role="progressbar" style="width: 25%;" aria-valuenow="25" aria-valuemin="0" aria-valuemax="100">25%</div></div></td></tr>
+		<tr><td>Clipname</td><td id="clipname"></td></tr>
+		</tbody>
+	</table>
+	
+	 <div class="row">
+		  <button class="btn btn-success btn-lg" onclick="previous()" style="margin: 10px"> Previous</button>
+		  <button class="btn btn-primary btn-lg" onclick="next()" style="margin: 10px"> Next</button>
+		  <button class="btn btn-primary btn-lg" onclick="skip10()" style="margin: 10px"> Skip 10</button>
+		  <button class="btn btn-primary btn-lg" onclick="skip100()" style="margin: 10px"> Skip 100</button>
+  </div>
+
+</div>
+
+<script>
+
+// setup
+
+function setupIndexAndClip(){
+	let current = ((currentCount+1)*100/filesCount)+"%";
+	$("#index").html((currentCount+1)+" / "+filesCount);
+
+	if(modifiedFiles.length > 0) {
+		current = ((currentCount+1)*100/modifiedFiles.length)+"%";
+		$("#index").html((currentCount+1)+" / "+modifiedFiles.length);
+	} 
+	$(".progress-bar").css("width", current);
+	$(".progress-bar").html(current);
+	$("#clipname").html(currentFile);
+}
+	
+function setupSrcs(){
+	setupIndexAndClip();
+	
+	for(let i=0; i<modelsCount; i++)
+             $("#clip"+i).attr("src", baseUrls[i]+currentFile);
+}
+
+function changeFileSet(prefix) {
+        modifiedFiles = [];
+
+	for(let i=0; i<filesCount; i++) {
+                if(fileNames[i].startsWith(prefix)) {
+			modifiedFiles.push(fileNames[i]);
+		}
+	}
+        currentCount = 0;
+	currentFile = modifiedFiles[currentCount];
+
+	setupSrcs();
+}
+
+function loadMsRecordings() {
+	changeFileSet("ms_");
+}
+
+function loadAudiosetRecordings() {
+	changeFileSet("audioset_");
+}
+
+function loadReverbRecordings() {
+	changeFileSet("reverb_");
+}
+
+function loadNoReverbRecordings() {
+	changeFileSet("noreverb_");
+}
+
+function searchNoiseType() {
+	modifiedFiles = [];
+
+	for(let i=0; i<filesCount; i++) {
+		console.log(document.getElementsByName('noiseType')[0].value);
+                if(fileNames[i].includes(document.getElementsByName('noiseType')[0].value)) {
+			modifiedFiles.push(fileNames[i]);
+		}
+	}
+
+	currentCount = 0;
+	if(modifiedFiles.length > 0) {
+		currentFile = modifiedFiles[currentCount];
+	} else {
+		currentFile = fileNames[currentCount];
+	}
+
+	setupSrcs();
+}
+
+function moveNextOrPrev(valueToAdd) {
+	if(modifiedFiles.length == 0) {
+		if(currentCount == (filesCount - valueToAdd))
+			alert("This is the last Clip. Hit 'Previous' to load the previous clip, or you may close the browser. ");
+		else{
+			currentCount = currentCount + valueToAdd;
+			currentFile = fileNames[currentCount];
+			setupSrcs();
+		}
+	} else {
+		if(currentCount == (modifiedFiles.length - valueToAdd))
+			alert("This is the last Clip. Hit 'Previous' to load the previous clip, or you may close the browser. ");
+		else{
+			currentCount = currentCount + valueToAdd;
+			currentFile = modifiedFiles[currentCount];
+			setupSrcs();
+		}
+	}
+}
+
+// set the scr to the next values on clicking next
+function next(){
+	moveNextOrPrev(1);		
+}
+
+function skip10(){
+	moveNextOrPrev(10);	
+}
+
+function skip100(){
+	moveNextOrPrev(100);
+}
+
+function previous(){
+
+	if(currentCount == 0)
+		alert("This is the very first Clip. Hit 'Next' to load the next clip. ");
+	else{
+		currentCount--;
+		currentFile = fileNames[currentCount];
+		if(modifiedFiles.length > 0)
+			currentFile = modifiedFiles[currentCount];
+		setupSrcs();
+	}	
+}
+
+setupIndexAndClip();
+
+var tbody = $("#table2>tbody");
+for(let i=0; i<modelsCount; i++)
+	tbody.append("<tr><td>"+modelsUsed[i]+"</td><td><audio controls id=clip"+i+" src='"+baseUrls[0]+currentFile+"' type='audio/wav'></audio></td></tr>");
+
+</script>
+	
+</html>

noisyspeech_synthesizer.cfg

@@ -0,0 +1,66 @@
+# Configuration for generating Noisy Speech Dataset
+
+# - sampling_rate: Specify the sampling rate. Default is 16 kHz
+# - audioformat: default is .wav
+# - audio_length: Minimum Length of each audio clip (noisy and clean speech) in seconds that will be generated by augmenting utterances. 
+# - silence_length: Duration of silence introduced between clean speech utterances.
+# - total_hours: Total number of hours of data required. Units are in hours. 
+# - snr_lower: Lower bound for SNR required (default: 0 dB)
+# - snr_upper: Upper bound for SNR required (default: 40 dB)
+# - target_level_lower: Lower bound for the target audio level before audiowrite (default: -35 dB)
+# - target_level_upper: Upper bound for the target audio level before audiowrite (default: -15 dB)
+# - total_snrlevels: Number of SNR levels required (default: 5, which means there are 5 levels between snr_lower and snr_upper)
+# - clean_activity_threshold: Activity threshold for clean speech
+# - noise_activity_threshold: Activity threshold for noise
+# - fileindex_start: Starting file ID that will be used in filenames
+# - fileindex_end: Last file ID that will be used in filenames
+# - is_test_set: Set it to True if it is the test set, else False for the training set
+# - noise_dir: Specify the directory path to all noise files
+# - Speech_dir: Specify the directory path to all clean speech files
+# - noisy_destination: Specify path to the destination directory to store noisy speech
+# - clean_destination: Specify path to the destination directory to store clean speech
+# - noise_destination: Specify path to the destination directory to store noise speech
+# - log_dir: Specify path to the directory to store all the log files
+
+# Configuration for unit tests
+# - snr_test: Set to True if SNR test is required, else False
+# - norm_test: Set to True if Normalization test is required, else False
+# - sampling_rate_test: Set to True if Sampling Rate test is required, else False
+# - clipping_test: Set to True if Clipping test is required, else False
+# - unit_tests_log_dir: Specify path to the directory where you want to store logs
+
+[noisy_speech]
+
+sampling_rate: 16000
+audioformat: *.wav
+audio_length: 30 
+silence_length: 0.2
+total_hours: 100
+snr_lower: 0
+snr_upper: 40
+randomize_snr: True
+target_level_lower: -35
+target_level_upper: -15
+total_snrlevels: 5 
+clean_activity_threshold: 0.6
+noise_activity_threshold: 0.0
+fileindex_start: None
+fileindex_end: None
+is_test_set: False
+noise_dir: \datasets\noise
+speech_dir: \datasets\clean
+noisy_destination: \noisy
+clean_destination: \clean
+noise_destination: \noise
+log_dir: \logs
+
+
+# Unit tests config
+snr_test: True
+norm_test: True
+sampling_rate_test = True
+clipping_test = True
+
+unit_tests_log_dir: .\unittests_logs
+
+

noisyspeech_synthesizer_multiprocessing.py

@@ -0,0 +1,342 @@
+"""
+@author: chkarada
+"""
+
+# Note that this file picks the clean speech files randomly, so it does not guarantee that all
+# source files will be used
+
+
+import os
+import glob
+import argparse
+import ast
+import configparser as CP
+from itertools import repeat
+import multiprocessing
+from multiprocessing import Pool
+import random
+from random import shuffle
+import librosa
+import numpy as np
+from audiolib import is_clipped, audioread, audiowrite, snr_mixer, activitydetector
+import utils
+
+
+PROCESSES = multiprocessing.cpu_count()
+MAXTRIES = 50
+MAXFILELEN = 100
+
+np.random.seed(2)
+random.seed(3)
+
+clean_counter = None
+noise_counter = None
+
+def init(args1, args2):
+    ''' store the counter for later use '''
+    global clean_counter, noise_counter
+    clean_counter = args1
+    noise_counter = args2
+
+
+def build_audio(is_clean, params, filenum, audio_samples_length=-1):
+    '''Construct an audio signal from source files'''
+
+    fs_output = params['fs']
+    silence_length = params['silence_length']
+    if audio_samples_length == -1:
+        audio_samples_length = int(params['audio_length']*params['fs'])
+
+    output_audio = np.zeros(0)
+    remaining_length = audio_samples_length
+    files_used = []
+    clipped_files = []
+
+    global clean_counter, noise_counter
+    if is_clean:
+        source_files = params['cleanfilenames']
+        idx_counter = clean_counter
+    else:    
+        source_files = params['noisefilenames']        
+        idx_counter = noise_counter
+
+    # initialize silence
+    silence = np.zeros(int(fs_output*silence_length))
+
+    # iterate through multiple clips until we have a long enough signal
+    tries_left = MAXTRIES
+    while remaining_length > 0 and tries_left > 0:
+
+        # read next audio file and resample if necessary
+        with idx_counter.get_lock():
+            idx_counter.value += 1
+            idx = idx_counter.value % np.size(source_files)
+
+        input_audio, fs_input = audioread(source_files[idx])
+        if fs_input != fs_output:
+            input_audio = librosa.resample(input_audio, fs_input, fs_output)
+
+        # if current file is longer than remaining desired length, and this is
+        # noise generation or this is training set, subsample it randomly
+        if len(input_audio) > remaining_length and (not is_clean or not params['is_test_set']):
+            idx_seg = np.random.randint(0, len(input_audio)-remaining_length)
+            input_audio = input_audio[idx_seg:idx_seg+remaining_length]
+
+        # check for clipping, and if found move onto next file
+        if is_clipped(input_audio):
+            clipped_files.append(source_files[idx])
+            tries_left -= 1
+            continue
+
+        # concatenate current input audio to output audio stream
+        files_used.append(source_files[idx])
+        output_audio = np.append(output_audio, input_audio)
+        remaining_length -= len(input_audio)
+
+        # add some silence if we have not reached desired audio length
+        if remaining_length > 0:
+            silence_len = min(remaining_length, len(silence))
+            output_audio = np.append(output_audio, silence[:silence_len])
+            remaining_length -= silence_len
+
+    if tries_left == 0:
+        print("Audio generation failed for filenum " + str(filenum))
+        return [], [], clipped_files
+
+    return output_audio, files_used, clipped_files
+
+
+def gen_audio(is_clean, params, filenum, audio_samples_length=-1):
+    '''Calls build_audio() to get an audio signal, and verify that it meets the
+       activity threshold'''
+
+    clipped_files = []
+    low_activity_files = []
+    if audio_samples_length == -1:
+        audio_samples_length = int(params['audio_length']*params['fs'])
+    if is_clean:
+        activity_threshold = params['clean_activity_threshold']
+    else:
+        activity_threshold = params['noise_activity_threshold']
+
+    while True:
+        audio, source_files, new_clipped_files = \
+            build_audio(is_clean, params, filenum, audio_samples_length)
+
+        clipped_files += new_clipped_files
+        if len(audio) < audio_samples_length:
+            continue
+
+        if activity_threshold == 0.0:
+            break
+
+        percactive = activitydetector(audio=audio)
+        if percactive > activity_threshold:
+            break
+        else:
+            low_activity_files += source_files
+
+    return audio, source_files, clipped_files, low_activity_files
+
+
+def main_gen(params, filenum):
+    '''Calls gen_audio() to generate the audio signals, verifies that they meet
+       the requirements, and writes the files to storage'''
+
+    print("Generating file #" + str(filenum))
+
+    clean_clipped_files = []
+    clean_low_activity_files = []
+    noise_clipped_files = []
+    noise_low_activity_files = []
+
+    while True:
+        # generate clean speech
+        clean, clean_source_files, clean_cf, clean_laf = \
+            gen_audio(True, params, filenum)
+        # generate noise
+        noise, noise_source_files, noise_cf, noise_laf = \
+            gen_audio(False, params, filenum, len(clean))
+
+        clean_clipped_files += clean_cf
+        clean_low_activity_files += clean_laf
+        noise_clipped_files += noise_cf
+        noise_low_activity_files += noise_laf
+
+        # mix clean speech and noise
+        # if specified, use specified SNR value
+        if not params['randomize_snr']:
+            snr = params['snr']
+        # use a randomly sampled SNR value between the specified bounds
+        else:
+            snr = np.random.randint(params['snr_lower'], params['snr_upper'])
+            
+        clean_snr, noise_snr, noisy_snr, target_level = snr_mixer(params=params, 
+                                                                  clean=clean, 
+                                                                  noise=noise, 
+                                                                  snr=snr)
+        # Uncomment the below lines if you need segmental SNR and comment the above lines using snr_mixer
+        #clean_snr, noise_snr, noisy_snr, target_level = segmental_snr_mixer(params=params, 
+        #                                                                    clean=clean, 
+        #                                                                    noise=noise, 
+        #                                                                    snr=snr)
+        # unexpected clipping
+        if is_clipped(clean_snr) or is_clipped(noise_snr) or is_clipped(noisy_snr):       
+            continue
+        else:
+            break
+
+    # write resultant audio streams to files
+    hyphen = '-'
+    clean_source_filenamesonly = [i[:-4].split(os.path.sep)[-1] for i in clean_source_files]
+    clean_files_joined = hyphen.join(clean_source_filenamesonly)[:MAXFILELEN]
+    noise_source_filenamesonly = [i[:-4].split(os.path.sep)[-1] for i in noise_source_files]
+    noise_files_joined = hyphen.join(noise_source_filenamesonly)[:MAXFILELEN]
+
+    noisyfilename = clean_files_joined + '_' + noise_files_joined + '_snr' + \
+                    str(snr) + '_fileid_' + str(filenum) + '.wav'
+    cleanfilename = 'clean_fileid_'+str(filenum)+'.wav'
+    noisefilename = 'noise_fileid_'+str(filenum)+'.wav'
+
+    noisypath = os.path.join(params['noisyspeech_dir'], noisyfilename)
+    cleanpath = os.path.join(params['clean_proc_dir'], cleanfilename)
+    noisepath = os.path.join(params['noise_proc_dir'], noisefilename)
+
+    audio_signals = [noisy_snr, clean_snr, noise_snr]
+    file_paths = [noisypath, cleanpath, noisepath]
+    
+    for i in range(len(audio_signals)):
+        try:
+            audiowrite(file_paths[i], audio_signals[i], params['fs'])
+        except Exception as e:
+            print(str(e))
+            pass
+
+    return clean_source_files, clean_clipped_files, clean_low_activity_files, \
+           noise_source_files, noise_clipped_files, noise_low_activity_files
+
+
+def extract_list(input_list, index):
+    output_list = [i[index] for i in input_list]
+    flat_output_list = [item for sublist in output_list for item in sublist]
+    flat_output_list = sorted(set(flat_output_list))
+    return flat_output_list
+
+
+def main_body():
+    '''Main body of this file'''
+
+    parser = argparse.ArgumentParser()
+
+    # Configurations: read noisyspeech_synthesizer.cfg and gather inputs
+    parser.add_argument('--cfg', default='noisyspeech_synthesizer.cfg',
+                        help='Read noisyspeech_synthesizer.cfg for all the details')
+    parser.add_argument('--cfg_str', type=str, default='noisy_speech')
+    args = parser.parse_args()
+
+    params = dict()
+    params['args'] = args
+    cfgpath = os.path.join(os.path.dirname(__file__), args.cfg)
+    assert os.path.exists(cfgpath), f'No configuration file as [{cfgpath}]'
+
+    cfg = CP.ConfigParser()
+    cfg._interpolation = CP.ExtendedInterpolation()
+    cfg.read(cfgpath)
+    params['cfg'] = cfg._sections[args.cfg_str]
+    cfg = params['cfg']
+
+    clean_dir = os.path.join(os.path.dirname(__file__), 'CleanSpeech')
+    if cfg['speech_dir'] != 'None':
+        clean_dir = cfg['speech_dir']
+    if not os.path.exists(clean_dir):
+        assert False, ('Clean speech data is required')
+
+    noise_dir = os.path.join(os.path.dirname(__file__), 'Noise')
+    if cfg['noise_dir'] != 'None':
+        noise_dir = cfg['noise_dir']
+    if not os.path.exists(noise_dir):
+        assert False, ('Noise data is required')
+
+    params['fs'] = int(cfg['sampling_rate'])
+    params['audioformat'] = cfg['audioformat']
+    params['audio_length'] = float(cfg['audio_length'])
+    params['silence_length'] = float(cfg['silence_length'])
+    params['total_hours'] = float(cfg['total_hours'])
+    
+    if cfg['fileindex_start'] != 'None' and cfg['fileindex_start'] != 'None':
+        params['fileindex_start'] = int(cfg['fileindex_start'])
+        params['fileindex_end'] = int(cfg['fileindex_end'])    
+        params['num_files'] = int(params['fileindex_end'])-int(params['fileindex_start'])
+    else:
+        params['num_files'] = int((params['total_hours']*60*60)/params['audio_length'])
+
+    print('Number of files to be synthesized:', params['num_files'])
+    params['is_test_set'] = utils.str2bool(cfg['is_test_set'])
+    params['clean_activity_threshold'] = float(cfg['clean_activity_threshold'])
+    params['noise_activity_threshold'] = float(cfg['noise_activity_threshold'])
+    params['snr_lower'] = int(cfg['snr_lower'])
+    params['snr_upper'] = int(cfg['snr_upper'])
+    params['randomize_snr'] = utils.str2bool(cfg['randomize_snr'])
+    params['target_level_lower'] = int(cfg['target_level_lower'])
+    params['target_level_upper'] = int(cfg['target_level_upper'])
+    
+    if 'snr' in cfg.keys():
+        params['snr'] = int(cfg['snr'])
+    else:
+        params['snr'] = int((params['snr_lower'] + params['snr_upper'])/2)
+
+    params['noisyspeech_dir'] = utils.get_dir(cfg, 'noisy_destination', 'noisy')
+    params['clean_proc_dir'] = utils.get_dir(cfg, 'clean_destination', 'clean')
+    params['noise_proc_dir'] = utils.get_dir(cfg, 'noise_destination', 'noise')
+
+    if 'speech_csv' in cfg.keys() and cfg['speech_csv'] != 'None':
+        cleanfilenames = pd.read_csv(cfg['speech_csv'])
+        cleanfilenames = cleanfilenames['filename']
+    else:
+        cleanfilenames = glob.glob(os.path.join(clean_dir, params['audioformat']))
+    params['cleanfilenames'] = cleanfilenames
+    shuffle(params['cleanfilenames'])
+    params['num_cleanfiles'] = len(params['cleanfilenames'])
+
+    params['noisefilenames'] = glob.glob(os.path.join(noise_dir, params['audioformat']))
+    shuffle(params['noisefilenames'])
+
+    # Invoke multiple processes and fan out calls to main_gen() to these processes
+    global clean_counter, noise_counter
+    clean_counter = multiprocessing.Value('i', 0)
+    noise_counter = multiprocessing.Value('i', 0)    
+    
+    multi_pool = multiprocessing.Pool(processes=PROCESSES, initializer = init, initargs = (clean_counter, noise_counter, ))
+    fileindices = range(params['num_files'])    
+    output_lists = multi_pool.starmap(main_gen, zip(repeat(params), fileindices))
+
+    flat_output_lists = []
+    num_lists = 6
+    for i in range(num_lists):
+        flat_output_lists.append(extract_list(output_lists, i))
+
+    # Create log directory if needed, and write log files of clipped and low activity files
+    log_dir = utils.get_dir(cfg, 'log_dir', 'Logs')
+
+    utils.write_log_file(log_dir, 'source_files.csv', flat_output_lists[0] + flat_output_lists[3])
+    utils.write_log_file(log_dir, 'clipped_files.csv', flat_output_lists[1] + flat_output_lists[4])
+    utils.write_log_file(log_dir, 'low_activity_files.csv', flat_output_lists[2] + flat_output_lists[5])
+    
+    # Compute and print stats about percentange of clipped and low activity files
+    total_clean = len(flat_output_lists[0]) + len(flat_output_lists[1]) + len(flat_output_lists[2])
+    total_noise = len(flat_output_lists[3]) + len(flat_output_lists[4]) + len(flat_output_lists[5])
+    pct_clean_clipped = round(len(flat_output_lists[1])/total_clean*100, 1)
+    pct_noise_clipped = round(len(flat_output_lists[4])/total_noise*100, 1)
+    pct_clean_low_activity = round(len(flat_output_lists[2])/total_clean*100, 1)
+    pct_noise_low_activity = round(len(flat_output_lists[5])/total_noise*100, 1)
+    
+    print("Of the " + str(total_clean) + " clean speech files analyzed, " + str(pct_clean_clipped) + \
+          "% had clipping, and " + str(pct_clean_low_activity) + "% had low activity " + \
+          "(below " + str(params['clean_activity_threshold']*100) + "% active percentage)")
+    print("Of the " + str(total_noise) + " noise files analyzed, " + str(pct_noise_clipped) + \
+          "% had clipping, and " + str(pct_noise_low_activity) + "% had low activity " + \
+          "(below " + str(params['noise_activity_threshold']*100) + "% active percentage)")
+
+
+if __name__ == '__main__':
+    main_body()

noisyspeech_synthesizer_singleprocess.py

@@ -0,0 +1,351 @@
+"""
+@author: chkarada
+"""
+
+# Note: This single process audio synthesizer will attempt to use each clean
+# speech sourcefile once, as it does not randomly sample from these files
+
+
+import os
+import glob
+import argparse
+import ast
+import configparser as CP
+import random
+from random import shuffle
+import librosa
+import numpy as np
+from audiolib import audioread, audiowrite, segmental_snr_mixer, snr_mixer, \
+                    activitydetector, is_clipped, add_clipping
+import utils
+import pandas as pd
+
+MAXTRIES = 50
+MAXFILELEN = 100
+
+np.random.seed(2)
+random.seed(3)
+
+def build_audio(is_clean, params, index, audio_samples_length=-1):
+    '''Construct an audio signal from source files'''
+
+    fs_output = params['fs']
+    silence_length = params['silence_length']
+    if audio_samples_length == -1:
+        audio_samples_length = int(params['audio_length']*params['fs'])
+
+    output_audio = np.zeros(0)
+    remaining_length = audio_samples_length
+    files_used = []
+    clipped_files = []
+
+    if is_clean:
+        source_files = params['cleanfilenames']
+        idx = index
+    else:
+        if 'noisefilenames' in params.keys():
+            source_files = params['noisefilenames']
+            idx = index
+        # if noise files are organized into individual subdirectories, pick a directory randomly
+        else:
+            noisedirs = params['noisedirs']
+            # pick a noise category randomly
+            idx_n_dir = np.random.randint(0, np.size(noisedirs))
+            source_files = glob.glob(os.path.join(noisedirs[idx_n_dir], 
+                                                  params['audioformat']))
+            shuffle(source_files)
+            # pick a noise source file index randomly
+            idx = np.random.randint(0, np.size(source_files))
+
+    # initialize silence
+    silence = np.zeros(int(fs_output*silence_length))
+
+    # iterate through multiple clips until we have a long enough signal
+    tries_left = MAXTRIES
+    while remaining_length > 0 and tries_left > 0:
+
+        # read next audio file and resample if necessary
+        idx = (idx + 1) % np.size(source_files)
+        input_audio, fs_input = audioread(source_files[idx])
+        if fs_input != fs_output:
+            input_audio = librosa.resample(input_audio, fs_input, fs_output)
+
+        # if current file is longer than remaining desired length, and this is
+        # noise generation or this is training set, subsample it randomly
+        if len(input_audio) > remaining_length and (not is_clean or not params['is_test_set']):
+            idx_seg = np.random.randint(0, len(input_audio)-remaining_length)
+            input_audio = input_audio[idx_seg:idx_seg+remaining_length]
+
+        # check for clipping, and if found move onto next file
+        if is_clipped(input_audio):
+            clipped_files.append(source_files[idx])
+            tries_left -= 1
+            continue
+
+        # concatenate current input audio to output audio stream
+        files_used.append(source_files[idx])
+        output_audio = np.append(output_audio, input_audio)
+        remaining_length -= len(input_audio)
+
+        # add some silence if we have not reached desired audio length
+        if remaining_length > 0:
+            silence_len = min(remaining_length, len(silence))
+            output_audio = np.append(output_audio, silence[:silence_len])
+            remaining_length -= silence_len
+
+    if tries_left == 0 and not is_clean and 'noisedirs' in params.keys():
+        print("There are not enough non-clipped files in the " + noisedirs[idx_n_dir] + \
+              " directory to complete the audio build")
+        return [], [], clipped_files, idx
+
+    return output_audio, files_used, clipped_files, idx
+
+
+def gen_audio(is_clean, params, index, audio_samples_length=-1):
+    '''Calls build_audio() to get an audio signal, and verify that it meets the
+       activity threshold'''
+
+    clipped_files = []
+    low_activity_files = []
+    if audio_samples_length == -1:
+        audio_samples_length = int(params['audio_length']*params['fs'])
+    if is_clean:
+        activity_threshold = params['clean_activity_threshold']
+    else:
+        activity_threshold = params['noise_activity_threshold']
+
+    while True:
+        audio, source_files, new_clipped_files, index = \
+            build_audio(is_clean, params, index, audio_samples_length)
+
+        clipped_files += new_clipped_files
+        if len(audio) < audio_samples_length:
+            continue
+
+        if activity_threshold == 0.0:
+            break
+
+        percactive = activitydetector(audio=audio)
+        if percactive > activity_threshold:
+            break
+        else:
+            low_activity_files += source_files
+
+    return audio, source_files, clipped_files, low_activity_files, index
+
+
+def main_gen(params):
+    '''Calls gen_audio() to generate the audio signals, verifies that they meet
+       the requirements, and writes the files to storage'''
+
+    clean_source_files = []
+    clean_clipped_files = []
+    clean_low_activity_files = []
+    noise_source_files = []
+    noise_clipped_files = []
+    noise_low_activity_files = []
+
+    clean_index = 0
+    noise_index = 0
+    file_num = params['fileindex_start']
+
+    while file_num <= params['fileindex_end']:
+        # generate clean speech
+        clean, clean_sf, clean_cf, clean_laf, clean_index = \
+            gen_audio(True, params, clean_index)
+        # generate noise
+        noise, noise_sf, noise_cf, noise_laf, noise_index = \
+            gen_audio(False, params, noise_index, len(clean))
+
+        clean_clipped_files += clean_cf
+        clean_low_activity_files += clean_laf
+        noise_clipped_files += noise_cf
+        noise_low_activity_files += noise_laf
+
+        # mix clean speech and noise
+        # if specified, use specified SNR value
+        if not params['randomize_snr']:
+            snr = params['snr']
+        # use a randomly sampled SNR value between the specified bounds
+        else:
+            snr = np.random.randint(params['snr_lower'], params['snr_upper'])
+
+        clean_snr, noise_snr, noisy_snr, target_level = snr_mixer(params=params, 
+                                                                  clean=clean, 
+                                                                  noise=noise, 
+                                                                  snr=snr)
+        # Uncomment the below lines if you need segmental SNR and comment the above lines using snr_mixer
+        #clean_snr, noise_snr, noisy_snr, target_level = segmental_snr_mixer(params=params, 
+        #                                                         clean=clean, 
+        #                                                          noise=noise, 
+        #                                                         snr=snr)
+        # unexpected clipping
+        if is_clipped(clean_snr) or is_clipped(noise_snr) or is_clipped(noisy_snr):
+            print("Warning: File #" + str(file_num) + " has unexpected clipping, " + \
+                  "returning without writing audio to disk")
+            continue
+
+        clean_source_files += clean_sf
+        noise_source_files += noise_sf
+
+        # write resultant audio streams to files
+        hyphen = '-'
+        clean_source_filenamesonly = [i[:-4].split(os.path.sep)[-1] for i in clean_sf]
+        clean_files_joined = hyphen.join(clean_source_filenamesonly)[:MAXFILELEN]
+        noise_source_filenamesonly = [i[:-4].split(os.path.sep)[-1] for i in noise_sf]
+        noise_files_joined = hyphen.join(noise_source_filenamesonly)[:MAXFILELEN]
+
+        noisyfilename = clean_files_joined + '_' + noise_files_joined + '_snr' + \
+                        str(snr) + '_tl' + str(target_level) + '_fileid_' + str(file_num) + '.wav'
+        cleanfilename = 'clean_fileid_'+str(file_num)+'.wav'
+        noisefilename = 'noise_fileid_'+str(file_num)+'.wav'
+
+        noisypath = os.path.join(params['noisyspeech_dir'], noisyfilename)
+        cleanpath = os.path.join(params['clean_proc_dir'], cleanfilename)
+        noisepath = os.path.join(params['noise_proc_dir'], noisefilename)
+
+        audio_signals = [noisy_snr, clean_snr, noise_snr]
+        file_paths = [noisypath, cleanpath, noisepath]
+
+        file_num += 1
+        for i in range(len(audio_signals)):
+            try:
+                audiowrite(file_paths[i], audio_signals[i], params['fs'])
+            except Exception as e:
+                print(str(e))
+
+
+    return clean_source_files, clean_clipped_files, clean_low_activity_files, \
+           noise_source_files, noise_clipped_files, noise_low_activity_files
+
+
+def main_body():
+    '''Main body of this file'''
+
+    parser = argparse.ArgumentParser()
+
+    # Configurations: read noisyspeech_synthesizer.cfg and gather inputs
+    parser.add_argument('--cfg', default='noisyspeech_synthesizer.cfg',
+                        help='Read noisyspeech_synthesizer.cfg for all the details')
+    parser.add_argument('--cfg_str', type=str, default='noisy_speech')
+    args = parser.parse_args()
+
+    params = dict()
+    params['args'] = args
+    cfgpath = os.path.join(os.path.dirname(__file__), args.cfg)
+    assert os.path.exists(cfgpath), f'No configuration file as [{cfgpath}]'
+
+    cfg = CP.ConfigParser()
+    cfg._interpolation = CP.ExtendedInterpolation()
+    cfg.read(cfgpath)
+    params['cfg'] = cfg._sections[args.cfg_str]
+    cfg = params['cfg']
+
+    clean_dir = os.path.join(os.path.dirname(__file__), 'CleanSpeech')
+    if cfg['speech_dir'] != 'None':
+        clean_dir = cfg['speech_dir']
+    if not os.path.exists(clean_dir):
+        assert False, ('Clean speech data is required')
+
+    noise_dir = os.path.join(os.path.dirname(__file__), 'Noise')
+    if cfg['noise_dir'] != 'None':
+        noise_dir = cfg['noise_dir']
+    if not os.path.exists:
+        assert False, ('Noise data is required')
+
+    params['fs'] = int(cfg['sampling_rate'])
+    params['audioformat'] = cfg['audioformat']
+    params['audio_length'] = float(cfg['audio_length'])
+    params['silence_length'] = float(cfg['silence_length'])
+    params['total_hours'] = float(cfg['total_hours'])
+    
+    if cfg['fileindex_start'] != 'None' and cfg['fileindex_start'] != 'None':
+        params['num_files'] = int(cfg['fileindex_end'])-int(cfg['fileindex_start'])
+        params['fileindex_start'] = int(cfg['fileindex_start'])
+        params['fileindex_end'] = int(cfg['fileindex_end'])
+    else:
+        params['num_files'] = int((params['total_hours']*60*60)/params['audio_length'])
+        params['fileindex_start'] = 0
+        params['fileindex_end'] = params['num_files']
+
+    print('Number of files to be synthesized:', params['num_files'])
+    
+    params['is_test_set'] = utils.str2bool(cfg['is_test_set'])
+    params['clean_activity_threshold'] = float(cfg['clean_activity_threshold'])
+    params['noise_activity_threshold'] = float(cfg['noise_activity_threshold'])
+    params['snr_lower'] = int(cfg['snr_lower'])
+    params['snr_upper'] = int(cfg['snr_upper'])
+    
+    params['randomize_snr'] = utils.str2bool(cfg['randomize_snr'])
+    params['target_level_lower'] = int(cfg['target_level_lower'])
+    params['target_level_upper'] = int(cfg['target_level_upper'])
+    
+    if 'snr' in cfg.keys():
+        params['snr'] = int(cfg['snr'])
+    else:
+        params['snr'] = int((params['snr_lower'] + params['snr_upper'])/2)
+
+    params['noisyspeech_dir'] = utils.get_dir(cfg, 'noisy_destination', 'noisy')
+    params['clean_proc_dir'] = utils.get_dir(cfg, 'clean_destination', 'clean')
+    params['noise_proc_dir'] = utils.get_dir(cfg, 'noise_destination', 'noise')
+
+    if 'speech_csv' in cfg.keys() and cfg['speech_csv'] != 'None':
+        cleanfilenames = pd.read_csv(cfg['speech_csv'])
+        cleanfilenames = cleanfilenames['filename']
+    else:
+        cleanfilenames = glob.glob(os.path.join(clean_dir, params['audioformat']))
+    params['cleanfilenames'] = cleanfilenames
+    shuffle(params['cleanfilenames'])
+    params['num_cleanfiles'] = len(params['cleanfilenames'])
+    # If there are .wav files in noise_dir directory, use those
+    # If not, that implies that the noise files are organized into subdirectories by type,
+    # so get the names of the non-excluded subdirectories
+    if 'noise_csv' in cfg.keys() and cfg['noise_csv'] != 'None':
+        noisefilenames = pd.read_csv(cfg['noise_csv'])
+        noisefilenames = noisefilenames['filename']
+    else:
+        noisefilenames = glob.glob(os.path.join(noise_dir, params['audioformat']))
+
+    if len(noisefilenames)!=0:
+        shuffle(noisefilenames)
+        params['noisefilenames'] = noisefilenames
+    else:
+        noisedirs = glob.glob(os.path.join(noise_dir, '*'))
+        if cfg['noise_types_excluded'] != 'None':
+            dirstoexclude = cfg['noise_types_excluded'].split(',')
+            for dirs in dirstoexclude:
+                noisedirs.remove(dirs)
+        shuffle(noisedirs)
+        params['noisedirs'] = noisedirs
+
+    # Call main_gen() to generate audio
+    clean_source_files, clean_clipped_files, clean_low_activity_files, \
+    noise_source_files, noise_clipped_files, noise_low_activity_files = main_gen(params)
+
+    # Create log directory if needed, and write log files of clipped and low activity files
+    log_dir = utils.get_dir(cfg, 'log_dir', 'Logs')
+
+    utils.write_log_file(log_dir, 'source_files.csv', clean_source_files + noise_source_files)
+    utils.write_log_file(log_dir, 'clipped_files.csv', clean_clipped_files + noise_clipped_files)
+    utils.write_log_file(log_dir, 'low_activity_files.csv', \
+                         clean_low_activity_files + noise_low_activity_files)
+
+    # Compute and print stats about percentange of clipped and low activity files
+    total_clean = len(clean_source_files) + len(clean_clipped_files) + len(clean_low_activity_files)
+    total_noise = len(noise_source_files) + len(noise_clipped_files) + len(noise_low_activity_files)
+    pct_clean_clipped = round(len(clean_clipped_files)/total_clean*100, 1)
+    pct_noise_clipped = round(len(noise_clipped_files)/total_noise*100, 1)
+    pct_clean_low_activity = round(len(clean_low_activity_files)/total_clean*100, 1)
+    pct_noise_low_activity = round(len(noise_low_activity_files)/total_noise*100, 1)
+
+    print("Of the " + str(total_clean) + " clean speech files analyzed, " + \
+          str(pct_clean_clipped) + "% had clipping, and " + str(pct_clean_low_activity) + \
+          "% had low activity " + "(below " + str(params['clean_activity_threshold']*100) + \
+          "% active percentage)")
+    print("Of the " + str(total_noise) + " noise files analyzed, " + str(pct_noise_clipped) + \
+          "% had clipping, and " + str(pct_noise_low_activity) + "% had low activity " + \
+          "(below " + str(params['noise_activity_threshold']*100) + "% active percentage)")
+
+
+if __name__ == '__main__':
+    main_body()

requirements.txt

@@ -0,0 +1,16 @@
+numpy
+soundfile
+librosa
+tempfile
+random
+argparse
+ast
+configparser
+itertools
+multiprocessing
+glob
+os
+pandas
+math
+logging
+onnxruntime

unit_tests_synthesizer.py

@@ -0,0 +1,186 @@
+import numpy as np
+import soundfile as sf
+import glob
+import argparse
+import os
+import utils
+import configparser as CP
+
+LOW_ENERGY_THRESH = -60
+
+def test_snr(clean, noise, expected_snr, snrtolerance=2):
+    '''Test for SNR
+    Note: It is not applicable for Segmental SNR'''
+    rmsclean = (clean**2).mean()**0.5
+    rmsnoise = (noise**2).mean()**0.5
+    actual_snr = 20*np.log10(rmsclean/rmsnoise)
+    return actual_snr > (expected_snr-snrtolerance) and actual_snr < (expected_snr+snrtolerance)
+
+def test_normalization(audio, expected_rms=-25, normtolerance=2):
+    '''Test for Normalization
+    Note: Set it to False if different target levels are used'''
+    rmsaudio = (audio**2).mean()**0.5
+    rmsaudiodb = 20*np.log10(rmsaudio)
+    return rmsaudiodb > (expected_rms-normtolerance) and rmsaudiodb < (expected_rms+normtolerance)
+
+def test_samplingrate(sr, expected_sr=16000):
+    '''Test to ensure all clips have same sampling rate'''
+    return expected_sr == sr
+
+def test_clipping(audio, num_consecutive_samples=3, clipping_threshold=0.01):
+    '''Test to detect clipping'''
+    clipping = False
+    for i in range(0, len(audio)-num_consecutive_samples-1):
+        audioseg = audio[i:i+num_consecutive_samples]
+        if abs(max(audioseg)-min(audioseg)) < clipping_threshold or abs(max(audioseg)) >= 1:
+            clipping = True
+            break
+    return clipping
+
+def test_zeros_beg_end(audio, num_zeros=16000, low_energy_thresh=LOW_ENERGY_THRESH):
+    '''Test if there are zeros in the beginning and the end of the signal'''
+    beg_segment_energy = 20*np.log10(audio[:num_zeros]**2).mean()**0.5
+    end_segment_energy = 20*np.log10(audio[-num_zeros:]**2).mean()**0.5
+    return beg_segment_energy < low_energy_thresh or end_segment_energy < low_energy_thresh
+
+def adsp_filtering_test(adsp, without_adsp):
+    diff = adsp - without_adsp
+    if any(val >0.0001 for val in diff):
+        
+    
+if __name__=='__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--cfg', default='noisyspeech_synthesizer.cfg')
+    parser.add_argument('--cfg_str', type=str, default='noisy_speech')
+
+    args = parser.parse_args()
+    
+    cfgpath = os.path.join(os.path.dirname(__file__), args.cfg)
+    assert os.path.exists(cfgpath), f'No configuration file as [{cfgpath}]'
+
+    cfg = CP.ConfigParser()
+    cfg._interpolation = CP.ExtendedInterpolation()
+    cfg.read(cfgpath)
+    cfg = cfg._sections[args.cfg_str]
+    
+    noisydir = cfg['noisy_train']
+    cleandir = cfg['clean_train']
+    noisedir = cfg['noise_train']
+    audioformat = cfg['audioformat']
+    
+    # List of noisy speech files
+    noisy_speech_filenames_big = glob.glob(os.path.join(noisydir, audioformat))
+    noisy_speech_filenames = noisy_speech_filenames_big[0:10]
+    # Initialize the lists
+    noisy_filenames_list = []
+    clean_filenames_list = []
+    noise_filenames_list = []
+    snr_results_list =[]
+    clean_norm_results_list = []
+    noise_norm_results_list = []
+    noisy_norm_results_list = []
+    clean_sr_results_list = []
+    noise_sr_results_list = []
+    noisy_sr_results_list = []
+    clean_clipping_results_list = []
+    noise_clipping_results_list = []
+    noisy_clipping_results_list = []
+
+    skipped_string = 'Skipped'
+    # Initialize the counters for stats
+    total_clips = len(noisy_speech_filenames)
+
+
+    for noisypath in noisy_speech_filenames:
+        # To do: add right paths to clean filename and noise filename
+        noisy_filename = os.path.basename(noisypath)
+        clean_filename = 'clean_fileid_'+os.path.splitext(noisy_filename)[0].split('fileid_')[1]+'.wav'
+        cleanpath = os.path.join(cleandir, clean_filename)
+        noise_filename = 'noise_fileid_'+os.path.splitext(noisy_filename)[0].split('fileid_')[1]+'.wav'
+        noisepath = os.path.join(noisedir, noise_filename)
+
+        noisy_filenames_list.append(noisy_filename)
+        clean_filenames_list.append(clean_filename)
+        noise_filenames_list.append(noise_filename)
+
+        # Read clean, noise and noisy signals
+        clean_signal, fs_clean = sf.read(cleanpath)
+        noise_signal, fs_noise = sf.read(noisepath)
+        noisy_signal, fs_noisy = sf.read(noisypath)
+
+        # SNR Test
+        # To do: add right path split to extract SNR
+        if utils.str2bool(cfg['snr_test']):
+            snr = int(noisy_filename.split('_snr')[1].split('_')[0])
+            snr_results_list.append(str(test_snr(clean=clean_signal, \
+             noise=noise_signal, expected_snr=snr)))
+        else:
+            snr_results_list.append(skipped_string)
+        
+        # Normalization test
+        if utils.str2bool(cfg['norm_test']):
+            tl = int(noisy_filename.split('_tl')[1].split('_')[0])
+            clean_norm_results_list.append(str(test_normalization(clean_signal)))
+            noise_norm_results_list.append(str(test_normalization(noise_signal)))
+            noisy_norm_results_list.append(str(test_normalization(noisy_signal, expected_rms=tl)))
+        else:
+            clean_norm_results_list.append(skipped_string)
+            noise_norm_results_list.append(skipped_string)
+            noisy_norm_results_list.append(skipped_string)
+        
+        # Sampling rate test
+        if utils.str2bool(cfg['sampling_rate_test']):
+            clean_sr_results_list.append(str(test_samplingrate(sr=fs_clean)))
+            noise_sr_results_list.append(str(test_samplingrate(sr=fs_noise)))
+            noisy_sr_results_list.append(str(test_samplingrate(sr=fs_noisy)))
+        else:
+            clean_sr_results_list.append(skipped_string)
+            noise_sr_results_list.append(skipped_string)
+            noisy_sr_results_list.append(skipped_string)
+        
+        # Clipping test
+        if utils.str2bool(cfg['clipping_test']):
+            clean_clipping_results_list.append(str(test_clipping(audio=clean_signal)))
+            noise_clipping_results_list.append(str(test_clipping(audio=noise_signal)))
+            noisy_clipping_results_list.append(str(test_clipping(audio=noisy_signal)))
+        else:
+            clean_clipping_results_list.append(skipped_string)
+            noise_clipping_results_list.append(skipped_string)
+            noisy_clipping_results_list.append(skipped_string)
+
+    # Stats
+    pc_snr_passed = round(snr_results_list.count('True')/total_clips*100, 1)
+    pc_clean_norm_passed = round(clean_norm_results_list.count('True')/total_clips*100, 1)
+    pc_noise_norm_passed = round(noise_norm_results_list.count('True')/total_clips*100, 1)
+    pc_noisy_norm_passed = round(noisy_norm_results_list.count('True')/total_clips*100, 1)
+    pc_clean_sr_passed = round(clean_sr_results_list.count('True')/total_clips*100, 1)
+    pc_noise_sr_passed = round(noise_sr_results_list.count('True')/total_clips*100, 1)
+    pc_noisy_sr_passed = round(noisy_sr_results_list.count('True')/total_clips*100, 1)
+    pc_clean_clipping_passed = round(clean_clipping_results_list.count('True')/total_clips*100, 1)
+    pc_noise_clipping_passed = round(noise_clipping_results_list.count('True')/total_clips*100, 1)
+    pc_noisy_clipping_passed = round(noisy_clipping_results_list.count('True')/total_clips*100, 1)
+
+    print('% clips that passed SNR test:', pc_snr_passed)
+    
+    print('% clean clips that passed Normalization tests:', pc_clean_norm_passed)
+    print('% noise clips that passed Normalization tests:', pc_noise_norm_passed)
+    print('% noisy clips that passed Normalization tests:', pc_noisy_norm_passed)
+
+    print('% clean clips that passed Sampling Rate tests:', pc_clean_sr_passed)
+    print('% noise clips that passed Sampling Rate tests:', pc_noise_sr_passed)
+    print('% noisy clips that passed Sampling Rate tests:', pc_noisy_sr_passed)
+
+    print('% clean clips that passed Clipping tests:', pc_clean_clipping_passed)
+    print('% noise clips that passed Clipping tests:', pc_noise_clipping_passed)
+    print('% noisy clips that passed Clipping tests:', pc_noisy_clipping_passed)
+
+    log_dir = utils.get_dir(cfg, 'unit_tests_log_dir', 'Unit_tests_logs')
+    
+    if not os.path.exists(log_dir):
+        log_dir = os.path.join(os.path.dirname(__file__), 'Unit_tests_logs')
+        os.makedirs(log_dir)
+    
+    utils.write_log_file(log_dir, 'unit_test_results.csv', [noisy_filenames_list, clean_filenames_list, \
+                            noise_filenames_list, snr_results_list, clean_norm_results_list, noise_norm_results_list, \
+                            noisy_norm_results_list, clean_sr_results_list, noise_sr_results_list, noisy_sr_results_list, \
+                            clean_clipping_results_list, noise_clipping_results_list, noisy_clipping_results_list])

utils.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Nov  1 10:28:41 2019
+
+@author: rocheng
+"""
+import os
+import csv
+from shutil import copyfile
+import glob
+
+def get_dir(cfg, param_name, new_dir_name):
+    '''Helper function to retrieve directory name if it exists,
+       create it if it doesn't exist'''
+
+    if param_name in cfg:
+        dir_name = cfg[param_name]
+    else:
+        dir_name = os.path.join(os.path.dirname(__file__), new_dir_name)
+    if not os.path.exists(dir_name):
+        os.makedirs(dir_name)
+    return dir_name
+
+
+def write_log_file(log_dir, log_filename, data):
+    '''Helper function to write log file'''
+    data = zip(*data)
+    with open(os.path.join(log_dir, log_filename), mode='w', newline='') as csvfile:
+        csvwriter = csv.writer(csvfile, delimiter=' ',
+                               quotechar='|', quoting=csv.QUOTE_MINIMAL)
+        for row in data:
+            csvwriter.writerow([row])
+
+
+def str2bool(string):
+    return string.lower() in ("yes", "true", "t", "1")
+
+
+def rename_copyfile(src_path, dest_dir, prefix='', ext='*.wav'):
+    srcfiles = glob.glob(f"{src_path}/"+ext)
+    for i in range(len(srcfiles)):
+        dest_path = os.path.join(dest_dir, prefix+'_'+os.path.basename(srcfiles[i]))
+        copyfile(srcfiles[i], dest_path)
+
+
+