Merge pull request #107 from jamarshon/numpyremove

 Remove numpy support in transforms.py and functional.py

test/test_transforms.py

@@ -107,18 +107,7 @@ class Tester(unittest.TestCase):
 
     def test_mu_law_companding(self):
 
-        sig = self.sig.clone()
-
         quantization_channels = 256
-        sig = self.sig.numpy()
-        sig = sig / np.abs(sig).max()
-        self.assertTrue(sig.min() >= -1. and sig.max() <= 1.)
-
-        sig_mu = transforms.MuLawEncoding(quantization_channels)(sig)
-        self.assertTrue(sig_mu.min() >= 0. and sig.max() <= quantization_channels)
-
-        sig_exp = transforms.MuLawExpanding(quantization_channels)(sig_mu)
-        self.assertTrue(sig_exp.min() >= -1. and sig_exp.max() <= 1.)
 
         sig = self.sig.clone()
         sig = sig / torch.abs(sig).max()

torchaudio/functional.py

-import numpy as np
+import math
 import torch
 
 
@@ -245,15 +245,15 @@ def create_dct(n_mfcc, n_mels, norm):
     outdim = n_mfcc
     dim = n_mels
     # http://en.wikipedia.org/wiki/Discrete_cosine_transform#DCT-II
-    n = np.arange(dim)
-    k = np.arange(outdim)[:, np.newaxis]
-    dct = np.cos(np.pi / dim * (n + 0.5) * k)
+    n = torch.arange(dim, dtype=torch.get_default_dtype())
+    k = torch.arange(outdim, dtype=torch.get_default_dtype())[:, None]
+    dct = torch.cos(math.pi / dim * (n + 0.5) * k)
     if norm == 'ortho':
-        dct[0] *= 1.0 / np.sqrt(2)
-        dct *= np.sqrt(2.0 / dim)
+        dct[0] *= 1.0 / math.sqrt(2.0)
+        dct *= math.sqrt(2.0 / dim)
     else:
         dct *= 2
-    return torch.Tensor(dct.T)
+    return dct.t()
 
 
 def MFCC(sig, mel_spect, log_mels, s2db, dct_mat):
@@ -302,7 +302,7 @@ def BLC2CBL(tensor):
 
 
 def mu_law_encoding(x, qc):
-    # type: (Tensor/ndarray, int) -> Tensor/ndarray
+    # type: (Tensor, int) -> Tensor
     """Encode signal based on mu-law companding.  For more info see the
     `Wikipedia Entry <https://en.wikipedia.org/wiki/%CE%9C-law_algorithm>`_
 
@@ -316,22 +316,19 @@ def mu_law_encoding(x, qc):
     Outputs:
         Tensor: Input after mu-law companding
     """
+    assert isinstance(x, torch.Tensor), 'mu_law_encoding expects a Tensor'
     mu = qc - 1.
-    if isinstance(x, np.ndarray):
-        x_mu = np.sign(x) * np.log1p(mu * np.abs(x)) / np.log1p(mu)
-        x_mu = ((x_mu + 1) / 2 * mu + 0.5).astype(int)
-    elif isinstance(x, torch.Tensor):
-        if not x.dtype.is_floating_point:
-            x = x.to(torch.float)
-        mu = torch.tensor(mu, dtype=x.dtype)
-        x_mu = torch.sign(x) * torch.log1p(mu *
-                                           torch.abs(x)) / torch.log1p(mu)
-        x_mu = ((x_mu + 1) / 2 * mu + 0.5).long()
+    if not x.dtype.is_floating_point:
+        x = x.to(torch.float)
+    mu = torch.tensor(mu, dtype=x.dtype)
+    x_mu = torch.sign(x) * torch.log1p(mu *
+                                       torch.abs(x)) / torch.log1p(mu)
+    x_mu = ((x_mu + 1) / 2 * mu + 0.5).to(torch.int64)
     return x_mu
 
 
 def mu_law_expanding(x_mu, qc):
-    # type: (Tensor/ndarray, int) -> Tensor/ndarray
+    # type: (Tensor, int) -> Tensor
     """Decode mu-law encoded signal.  For more info see the
     `Wikipedia Entry <https://en.wikipedia.org/wiki/%CE%9C-law_algorithm>`_
 
@@ -345,14 +342,11 @@ def mu_law_expanding(x_mu, qc):
     Outputs:
         Tensor: Input after decoding
     """
+    assert isinstance(x_mu, torch.Tensor), 'mu_law_expanding expects a Tensor'
     mu = qc - 1.
-    if isinstance(x_mu, np.ndarray):
-        x = ((x_mu) / mu) * 2 - 1.
-        x = np.sign(x) * (np.exp(np.abs(x) * np.log1p(mu)) - 1.) / mu
-    elif isinstance(x_mu, torch.Tensor):
-        if not x_mu.dtype.is_floating_point:
-            x_mu = x_mu.to(torch.float)
-        mu = torch.tensor(mu, dtype=x_mu.dtype)
-        x = ((x_mu) / mu) * 2 - 1.
-        x = torch.sign(x) * (torch.exp(torch.abs(x) * torch.log1p(mu)) - 1.) / mu
+    if not x_mu.dtype.is_floating_point:
+        x_mu = x_mu.to(torch.float)
+    mu = torch.tensor(mu, dtype=x_mu.dtype)
+    x = ((x_mu) / mu) * 2 - 1.
+    x = torch.sign(x) * (torch.exp(torch.abs(x) * torch.log1p(mu)) - 1.) / mu
     return x

torchaudio/transforms.py

 from __future__ import division, print_function
 from warnings import warn
+import math
 import torch
-import numpy as np
 from . import functional as F
 
 
@@ -234,7 +234,7 @@ class SpectrogramToDB(object):
         self.multiplier = 10. if stype == "power" else 20.
         self.amin = 1e-10
         self.ref_value = 1.
-        self.db_multiplier = np.log10(np.maximum(self.amin, self.ref_value))
+        self.db_multiplier = math.log10(max(self.amin, self.ref_value))
 
     def __call__(self, spec):
         # numerically stable implementation from librosa
@@ -403,10 +403,10 @@ class MuLawEncoding(object):
         """
 
         Args:
-            x (FloatTensor/LongTensor or ndarray)
+            x (FloatTensor/LongTensor)
 
         Returns:
-            x_mu (LongTensor or ndarray)
+            x_mu (LongTensor)
 
         """
         return F.mu_law_encoding(x, self.qc)
@@ -434,10 +434,10 @@ class MuLawExpanding(object):
         """
 
         Args:
-            x_mu (FloatTensor/LongTensor or ndarray)
+            x_mu (Tensor)
 
         Returns:
-            x (FloatTensor or ndarray)
+            x (Tensor)
 
         """
         return F.mu_law_expanding(x_mu, self.qc)