Styjun

I am working a program that needs to mix audio arrays together with a given starting index. For example

signal1 = np.array([1,2,3,4])
signal2 = np.array([5,5,5])
signal3 = np.array([7,7,7,7])
sig = np.array([signal1,signal2,signal3])
onset(0, 2, 8)
result = mixing_function(sig,onset)

Based on the onset, signal2 will add to signal1 from index 2, and signal3 will add to the mix from index 8, so the mixing part will be zero padded. It should return:

[1,2,8,9,5,0,0,0,7,7,7,7]

I am not sure what is the effective way to write the code for this. For now, I created a zero array with the maximum length maxlen. Then I add each element in sig to the corresponding index range of the result :

def mixing_function(sig,onset):
 maxlen = np.max([o + len(s) for o, s in zip(onset, sig)])
 result = np.zeros(maxlen)
 for i in range(len(onset)):
 result[onset[i]:onset[i] + len(sig[i])] += sig[i] 
 return result

However, this can be quite slow especially when there are many signals being mixed together all with different onsets. Please advice if there is a much more efficient way .

Many thanks

J

Here are some stats for different solutions to the problem. I was able to squeeze a little more performance by vectorizing the implementation to get maxlen, but besides that, I think you will have to try cython or trying other programming languages.

import numpy as np
from numba import jit
from time import time
np.random.seed(42)

def mixing_function(sig, onset):
 maxlen = np.max([o + len(s) for o, s in zip(onset, sig)])
 result = np.zeros(maxlen)
 for i in range(len(onset)):
 result[onset[i]:onset[i] + len(sig[i])] += sig[i] 
 return result

def mix(sig, onset):
 siglengths = np.vectorize(len)(sig)
 maxlen = max(onset + siglengths)
 result = np.zeros(maxlen)
 for i in range(len(sig)):
 result[onset[i]: onset[i]+siglengths[i]] += sig[i]
 return result

@jit(nopython=True)
def mixnumba(sig, onset):
 # maxlen = np.max([onset[i] + len(sig[i]) for i in range(len(sig))])
 maxlen = -1
 for i in range(len(sig)):
 maxlen = max(maxlen, sig[i].size + onset[i])
 result = np.zeros(maxlen)
 for i in range(len(sig)):
 result[onset[i]: onset[i] + sig[i].size] += sig[i]
 return result

def signal_adder_with_onset(data, onset):
 data = np.array(data)
 # Get lengths of each row of data
 lens = np.array([len(i) for i in data])
 #adjust with offset for max possible lengths
 max_size = lens + onset
 # Mask of valid places in each row
 mask = ((np.arange(max_size.max()) >= onset.reshape(-1, 1)) 
 & (np.arange(max_size.max()) < (lens + onset).reshape(-1, 1)))

 # Setup output array and put elements from data into masked positions
 out = np.zeros(mask.shape, dtype=data.dtype) #could perhaps change dtype here
 out[mask] = np.concatenate(data)
 return out.sum(axis=0)

sigbig = [np.random.randn(np.random.randint(1000, 10000)) for _ in range(10000)]
onsetbig = np.random.randint(0, 10000, size=10000)
sigrepeat = np.repeat(sig, 500000).tolist()
onsetrepeat = np.repeat(onset, 500000)

assert all(mixing_function(sigbig, onsetbig) == mix(sigbig, onsetbig))
assert all(mixing_function(sigbig, onsetbig) == mixnumba(sigbig, onsetbig))
assert all(mixing_function(sigbig, onsetbig) == signal_adder_with_onset(sigbig, onsetbig))

%timeit result = mixing_function(sigbig, onsetbig)
%timeit result = mix(sigbig, onsetbig)
%timeit result = mixnumba(sigbig, onsetbig)
%timeit result = signal_adder_with_onset(sigbig, onsetbig)
# Output
114 ms ± 1.97 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
108 ms ± 2.53 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
368 ms ± 8.22 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
13.4 s ± 211 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit result = mixing_function(sigrepeat, onsetrepeat)
%timeit result = mix(sigrepeat, onsetrepeat)
%timeit result = mixnumba(sigrepeat, onsetrepeat)
%timeit result = signal_adder_with_onset(sigrepeat.tolist(), onsetrepeat)
# Output
933 ms ± 6.43 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
803 ms ± 21.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
4.07 s ± 85.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
254 ms ± 11.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

TL.DR.
Marginal performance improvement (around 10% faster) by using np.vectorize in order to get maxlen for long signals of random length. Note that for many small signals, @Paritosh Singh answer performs faster than the others.

If you offset the signals, then put them in a data frame, NaN will be added to columns to make all the rows the same length. Then you can do df.sum(). That will return a float rather than int, however.

Try numpy zero arrays of equal length with the signals appropriately inserted and simply performing 3 numpy array additions. Should speed things up considerably.

def mixing_function(sig,onset):
 maxlen = np.max([o + len(s) for o, s in zip(onset, sig)])
 sig1 = np.zeros(maxlen)
 sig2 = np.zeros(maxlen)
 sig3 = np.zeros(maxlen)
 sig1[onset[0]:onset[0] + len(sig[0])] = sig[0]
 sig2[onset[1]:onset[1] + len(sig[1])] = sig[1]
 sig3[onset[2]:onset[2] + len(sig[2])] = sig[2]
 result = sig1+sig2+sig3
 print(sig1)
 print(sig2)
 print(sig3)
 print(result)

Here's an attempt that should do the trick.

def signal_adder_with_onset(data, onset):
 # Get lengths of each row of data
 lens = np.array([len(i) for i in data])
 #adjust with offset for max possible lengths
 max_size = lens + onset
 # Mask of valid places in each row
 mask = ((np.arange(max_size.max()) >= onset.reshape(-1, 1)) 
 & (np.arange(max_size.max()) < (lens + onset).reshape(-1, 1)))

 # Setup output array and put elements from data into masked positions
 out = np.zeros(mask.shape, dtype=data.dtype) #could perhaps change dtype here
 out[mask] = np.concatenate(data)
 return out.sum(axis=0)

import numpy as np
signal1 = np.array([1,2,3,4])
signal2 = np.array([5,5,5])
signal3 = np.array([7,7,7,7])
sig = np.array([signal1,signal2,signal3])
onset = np.array((0, 2, 8))
result = signal_adder_with_onset(sig, onset)
print(result)
#[1 2 8 9 5 0 0 0 7 7 7 7]

Edit: Vectorized operations only kick in with more data, and are slower with smaller amounts of data.

Added for comparison

import time

def signal_adder_with_onset(data, onset):
 # Get lengths of each row of data
 lens = np.array([len(i) for i in data])
 #adjust with offset for max possible lengths
 max_size = lens + onset
 # Mask of valid places in each row
 mask = ((np.arange(max_size.max()) >= onset.reshape(-1, 1)) 
 & (np.arange(max_size.max()) < (lens + onset).reshape(-1, 1)))

 # Setup output array and put elements from data into masked positions
 out = np.zeros(mask.shape, dtype=data.dtype) #could perhaps change dtype here
 out[mask] = np.concatenate(data)
 return out.sum(axis=0)

def mixing_function(sig,onset):
 maxlen = np.max([o + len(s) for o, s in zip(onset, sig)])
 result = np.zeros(maxlen)
 for i in range(len(onset)):
 result[onset[i]:onset[i] + len(sig[i])] += sig[i] 
 return result

import numpy as np
signal1 = np.array([1,2,3,4])
signal2 = np.array([5,5,5])
signal3 = np.array([7,7,7,7])
sig = np.array([signal1,signal2,signal3])
sig = np.repeat(sig, 1000000)
onset = np.array((0, 2, 8))
onset = np.repeat(onset, 1000000)
start1 = time.time()
result = signal_adder_with_onset(sig, onset)
end1 = time.time()
start2 = time.time()
result2 = mixing_function(sig,onset)
end2 = time.time()
print(f"Original function: end2 - start2 n Vectorized function: end1 - start1")
print(result)
#Output:
Original function: 9.28258752822876 
 Vectorized function: 2.5798118114471436
[1000000 2000000 8000000 9000000 5000000 0 0 0 7000000 7000000 7000000
 7000000]