我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.lib.stride_tricks.as_strided()。
def stft(sig, frameSize, overlapFac=0.75, window=np.hanning): """ short time fourier transform of audio signal """ win = window(frameSize) hopSize = int(frameSize - np.floor(overlapFac * frameSize)) # zeros at beginning (thus center of 1st window should be for sample nr. 0) # samples = np.append(np.zeros(np.floor(frameSize / 2.0)), sig) samples = np.array(sig, dtype='float64') # cols for windowing cols = np.ceil((len(samples) - frameSize) / float(hopSize)) + 1 # zeros at end (thus samples can be fully covered by frames) # samples = np.append(samples, np.zeros(frameSize)) frames = stride_tricks.as_strided( samples, shape=(cols, frameSize), strides=(samples.strides[0] * hopSize, samples.strides[0])).copy() frames *= win return np.fft.rfft(frames) # all the definition of the flowing variable can be found # train_net.py
def prepare_olapsequences(ms, vs, lsize, olap, bsize): from numpy.lib import stride_tricks global trimframe trimframe = ms.shape[0] % (lsize - olap) print(trimframe) if trimframe != 0: ms = np.pad(ms, ((0,trimframe), (0,0)), 'constant', constant_values=(0,0)) vs = np.pad(vs, ((0,trimframe), (0,0)), 'constant', constant_values=(0,0)) ms = stride_tricks.as_strided(ms, shape=(ms.shape[0] / (lsize - olap), lsize, ms.shape[1]), strides=(ms.strides[0] * (lsize - olap), ms.strides[0], ms.strides[1])) ms = ms[:-1, :, :] vs = stride_tricks.as_strided(vs, shape=(vs.shape[0] / (lsize - olap), lsize, vs.shape[1]), strides=(vs.strides[0] * (lsize - olap), vs.strides[0], vs.strides[1])) vs = vs[:-1, :, :] btrimframe = (ms.shape[0] % bsize) if btrimframe != 0: ms = ms[:-btrimframe, :, :] vs = vs[:-btrimframe, :, :] #print(ms.max(), ms.min(), vs.max(), vs.min()) #print(ms.shape, vs.shape) return ms, vs
def stft(sig, frameSize, overlapFac=0.75, window=np.hanning): """ short time fourier transform of audio signal """ win = window(frameSize) hopSize = int(frameSize - np.floor(overlapFac * frameSize)) # zeros at beginning (thus center of 1st window should be for sample nr. 0) # samples = np.append(np.zeros(np.floor(frameSize / 2.0)), sig) samples = np.array(sig, dtype='float64') # cols for windowing cols = np.floor((len(samples) - frameSize) / float(hopSize)) # zeros at end (thus samples can be fully covered by frames) # samples = np.append(samples, np.zeros(frameSize)) frames = stride_tricks.as_strided( samples, shape=(cols, frameSize), strides=(samples.strides[0] * hopSize, samples.strides[0])).copy() frames *= win return np.fft.rfft(frames)
def stft(sig, frameSize, overlapFac=0.75, window=np.hanning): """ short time fourier transform of audio signal """ win = window(frameSize) hopSize = int(frameSize - np.floor(overlapFac * frameSize)) # zeros at beginning (thus center of 1st window should be for sample nr. 0) # samples = np.append(np.zeros(np.floor(frameSize / 2.0)), sig) samples = np.array(sig, dtype='float64') # cols for windowing cols = np.ceil((len(samples) - frameSize) / float(hopSize)) + 1 # zeros at end (thus samples can be fully covered by frames) # samples = np.append(samples, np.zeros(frameSize)) frames = stride_tricks.as_strided( samples, shape=(cols, frameSize), strides=(samples.strides[0] * hopSize, samples.strides[0])).copy() frames *= win return np.fft.rfft(frames)
def stft(sig, frameSize, overlapFac=0.75, window=np.hanning): """ short time fourier transform of audio signal """ win = window(frameSize) hopSize = int(frameSize - np.floor(overlapFac * frameSize)) # zeros at beginning (thus center of 1st window should be for sample nr. 0) # samples = np.append(np.zeros(np.floor(frameSize / 2.0)), sig) samples = np.array(sig, dtype='float64') # cols for windowing cols = np.ceil((len(samples) - frameSize) / float(hopSize)) + 1 # zeros at end (thus samples can be fully covered by frames) samples = np.append(samples, np.zeros(frameSize)) frames = stride_tricks.as_strided( samples, shape=(cols, frameSize), strides=(samples.strides[0] * hopSize, samples.strides[0])).copy() frames *= win return np.fft.rfft(frames)
def sine_window(X): """ Apply a sinusoid window to X. Parameters ---------- X : ndarray, shape=(n_samples, n_features) Input array of samples Returns ------- X_windowed : ndarray, shape=(n_samples, n_features) Windowed version of X. """ i = np.arange(X.shape[1]) win = np.sin(np.pi * (i + 0.5) / X.shape[1]) row_stride = 0 col_stride = win.itemsize strided_win = as_strided(win, shape=X.shape, strides=(row_stride, col_stride)) return X * strided_win
def kaiserbessel_window(X, alpha=6.5): """ Apply a Kaiser-Bessel window to X. Parameters ---------- X : ndarray, shape=(n_samples, n_features) Input array of samples alpha : float, optional (default=6.5) Tuning parameter for Kaiser-Bessel function. alpha=6.5 should make perfect reconstruction possible for DCT. Returns ------- X_windowed : ndarray, shape=(n_samples, n_features) Windowed version of X. """ beta = np.pi * alpha win = sg.kaiser(X.shape[1], beta) row_stride = 0 col_stride = win.itemsize strided_win = as_strided(win, shape=X.shape, strides=(row_stride, col_stride)) return X * strided_win
def deltaDeEmbedSum(delta, width): nSeg = delta.shape[0] nObs = delta.shape[1] nDim = delta.shape[2] lags = width-1 origDim = nDim // width pad = np.zeros((nSeg,lags,nDim), dtype=delta.dtype) delta = delta[:,::-1,:] delta = np.concatenate((pad,delta,pad), axis=1) flags = delta.flags assert flags.c_contiguous sz = delta.itemsize deEmb = npst.as_strided(delta, shape=(width, nSeg, nObs+lags, origDim), strides=(origDim*(width+1)*sz, delta.shape[1]*delta.shape[2]*sz, width*origDim*sz, sz))[:,:,::-1,:] return deEmb.sum(axis=0)#[:,::-1,:]
def expand(T, w): if len(w) > 1: # X AND Z (im2col) w = (1,) + w T = view_as_windows(T, w+(1,)*(T.ndim-len(w))).squeeze(tuple(range(T.ndim+4, T.ndim*2))) T = np.transpose (T, range(4) + range(T.ndim-4, T.ndim) + range(4, T.ndim-4)) T = np.squeeze (T, 4) else: # Z ONLY (2nd-stage expansion) sh = list(T.shape ); sh[1] = w[0] st = list(T.strides); st[1] = 0 T = T if T.shape[1] == w[0] else as_strided(T, sh, st) return T
def _strided_from_memmap(filename, dtype, mode, offset, order, shape, strides, total_buffer_len): """Reconstruct an array view on a memory mapped file.""" if mode == 'w+': # Do not zero the original data when unpickling mode = 'r+' if strides is None: # Simple, contiguous memmap return make_memmap(filename, dtype=dtype, shape=shape, mode=mode, offset=offset, order=order) else: # For non-contiguous data, memmap the total enclosing buffer and then # extract the non-contiguous view with the stride-tricks API base = make_memmap(filename, dtype=dtype, shape=total_buffer_len, mode=mode, offset=offset, order=order) return as_strided(base, shape=shape, strides=strides)
def handle_rolling(agg, granularity, timestamps, values, is_aggregated, references, window): if window > len(values): raise exceptions.UnAggregableTimeseries( references, "Rolling window '%d' is greater than serie length '%d'" % (window, len(values)) ) timestamps = timestamps[window - 1:] values = values.T # rigtorp.se/2011/01/01/rolling-statistics-numpy.html shape = values.shape[:-1] + (values.shape[-1] - window + 1, window) strides = values.strides + (values.strides[-1],) new_values = AGG_MAP[agg](as_strided(values, shape=shape, strides=strides), axis=-1) return granularity, timestamps, new_values.T, is_aggregated
def stft(sig, frameSize, overlapFac=0.75, window=np.hanning): """ short time fourier transform of audio signal """ win = window(frameSize) hopSize = int(frameSize - np.floor(overlapFac * frameSize)) # zeros at beginning (thus center of 1st window should be for sample nr. 0) # samples = np.append(np.zeros(np.floor(frameSize / 2.0)), sig) samples = np.array(sig, dtype='float64') # cols for windowing cols = np.ceil((len(samples) - frameSize) / float(hopSize)) # zeros at end (thus samples can be fully covered by frames) # samples = np.append(samples, np.zeros(frameSize)) frames = stride_tricks.as_strided( samples, shape=(cols, frameSize), strides=(samples.strides[0] * hopSize, samples.strides[0])).copy() frames *= win return np.fft.rfft(frames)
def _strided_from_memmap(filename, dtype, mode, offset, order, shape, strides, total_buffer_len): """Reconstruct an array view on a memmory mapped file""" if mode == 'w+': # Do not zero the original data when unpickling mode = 'r+' if strides is None: # Simple, contiguous memmap return np.memmap(filename, dtype=dtype, shape=shape, mode=mode, offset=offset, order=order) else: # For non-contiguous data, memmap the total enclosing buffer and then # extract the non-contiguous view with the stride-tricks API base = np.memmap(filename, dtype=dtype, shape=total_buffer_len, mode=mode, offset=offset, order=order) return as_strided(base, shape=shape, strides=strides)
def _windowed_view(x, window_size): """Create a 2d windowed view of a 1d array. `x` must be a 1d numpy array. `numpy.lib.stride_tricks.as_strided` is used to create the view. The data is not copied. Example: >>> x = np.array([1, 2, 3, 4, 5, 6]) >>> _windowed_view(x, 3) array([[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]]) """ y = as_strided(x, shape=(x.size - window_size + 1, window_size), strides=(x.strides[0], x.strides[0])) return y
def _windowed_view(x, window_units): """Create a 2d windowed view of a 1d array. `x` must be a 1d numpy array. `numpy.lib.stride_tricks.as_strided` is used to create the view. The data is not copied. Example: >>> x = np.array([1, 2, 3, 4, 5, 6]) >>> _windowed_view(x, 3) array([[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]]) """ y = as_strided(x, shape=(x.size - window_units + 1, window_units), strides=(x.strides[0], x.strides[0])) return y
def stft(sig, frame_size, overlap_fac=0.5, window=np.hanning): """ short time fourier transform of audio signal """ win = window(frame_size) hop_size = int(frame_size - np.floor(overlap_fac * frame_size)) # zeros at beginning (thus center of 1st window should be for sample nr. 0) samples = np.append(np.zeros(np.floor(frame_size / 2.0)), sig) # cols for windowing cols = np.ceil((len(samples) - frame_size) / float(hop_size)) + 1 # zeros at end (thus samples can be fully covered by frames) samples = np.append(samples, np.zeros(frame_size)) frames = stride_tricks.as_strided( samples, shape=(cols, frame_size), strides=( samples.strides[0] * hop_size, samples.strides[0] ) ).copy() frames *= win return np.fft.rfft(frames)
def sliding_window_1D(x, windowLen): """ Constructs a 2D array whose rows are the data in a sliding window that advances one time step at a time. Parameters ---------- x : 1D, array-like An ordered collection of objects windowLen : int > 0 The legnth of the sliding window Returns ------- X : 2D array A matrix such that X[i, :] = x[i:i+windowLen] """ x = x.flatten() numBytes = x.strides[0] numSubseqs = len(x) - windowLen + 1 return as_strided(x, strides=(numBytes, numBytes), shape=(numSubseqs, windowLen))
def repeat_first_axis(array, count): """ Restride `array` to repeat `count` times along the first axis. Parameters ---------- array : np.array The array to restride. count : int Number of times to repeat `array`. Returns ------- result : array Array of shape (count,) + array.shape, composed of `array` repeated `count` times along the first axis. Example ------- >>> from numpy import arange >>> a = arange(3); a array([0, 1, 2]) >>> repeat_first_axis(a, 2) array([[0, 1, 2], [0, 1, 2]]) >>> repeat_first_axis(a, 4) array([[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]) Notes ---- The resulting array will share memory with `array`. If you need to assign to the input or output, you should probably make a copy first. See Also -------- repeat_last_axis """ return as_strided(array, (count,) + array.shape, (0,) + array.strides)
def _grid_creator(self): """Creates a grid according to the GridSpec.""" shape_fa = self.grid_spec.get_interogation_grid_shape() shape_fb = self.grid_spec.get_search_grid_shape() strides_fa = self.grid_spec.get_interogation_grid_strides() strides_fb = self.grid_spec.get_search_grid_strides() self.grid_a = as_strided(self.frame_a, strides=strides_fa, shape=shape_fa) self.grid_b = as_strided(self._padded_fb, strides=strides_fb, shape=shape_fb)
def stft(sig, frameSize, overlapFac=0.5, window=np.hanning): win = window(frameSize) hopSize = int(frameSize - np.floor(overlapFac * frameSize)) # zeros at beginning (thus center of 1st window should be for sample nr. 0) samples = np.append(np.zeros(np.floor(frameSize/2.0)), sig) # cols for windowing cols = np.ceil( (len(samples) - frameSize) / float(hopSize)) + 1 # zeros at end (thus samples can be fully covered by frames) samples = np.append(samples, np.zeros(frameSize)) frames = stride_tricks.as_strided(samples, shape=(cols, frameSize), strides=(samples.strides[0]*hopSize, samples.strides[0])).copy() frames *= win return np.fft.rfft(frames)
def process(self, wave): wave.check_mono() wave = wave.zero_pad(self.half_window, self.half_window) num_frames = int(1 + np.ceil((wave.shape[0] - self.window_size) / float(self.hop_size))) col_size = wave.strides[0] frames = stride_tricks.as_strided(wave, shape=(num_frames, self.window_size), strides=(col_size*self.hop_size, col_size)).copy() frames *= self.window transform = np.fft.rfft(frames, self.fft_size) return audio.Spectrogram(transform.T, wave.sample_rate, len(self.window), self.hop_size)
def tile_array(a, b1, b2): r, c = a.shape rs, cs = a.strides x = as_strided(a, (r, b1, c, b2), (rs, 0, cs, 0)) return x.reshape(r*b1, c*b2)
def test_internal_overlap_manual(): # Stride tricks can construct arrays with internal overlap # We don't care about memory bounds, the array is not # read/write accessed x = np.arange(1).astype(np.int8) # Check low-dimensional special cases check_internal_overlap(x, False) # 1-dim check_internal_overlap(x.reshape([]), False) # 0-dim a = as_strided(x, strides=(3, 4), shape=(4, 4)) check_internal_overlap(a, False) a = as_strided(x, strides=(3, 4), shape=(5, 4)) check_internal_overlap(a, True) a = as_strided(x, strides=(0,), shape=(0,)) check_internal_overlap(a, False) a = as_strided(x, strides=(0,), shape=(1,)) check_internal_overlap(a, False) a = as_strided(x, strides=(0,), shape=(2,)) check_internal_overlap(a, True) a = as_strided(x, strides=(0, -9993), shape=(87, 22)) check_internal_overlap(a, True) a = as_strided(x, strides=(0, -9993), shape=(1, 22)) check_internal_overlap(a, False) a = as_strided(x, strides=(0, -9993), shape=(0, 22)) check_internal_overlap(a, False)
def test_internal_overlap_fuzz(): # Fuzz check; the brute-force check is fairly slow x = np.arange(1).astype(np.int8) overlap = 0 no_overlap = 0 min_count = 100 rng = np.random.RandomState(1234) while min(overlap, no_overlap) < min_count: ndim = rng.randint(1, 4, dtype=np.intp) strides = tuple(rng.randint(-1000, 1000, dtype=np.intp) for j in range(ndim)) shape = tuple(rng.randint(1, 30, dtype=np.intp) for j in range(ndim)) a = as_strided(x, strides=strides, shape=shape) result = check_internal_overlap(a) if result: overlap += 1 else: no_overlap += 1
def __init__(self, *shape): if len(shape) == 1 and isinstance(shape[0], tuple): shape = shape[0] x = as_strided(_nx.zeros(1), shape=shape, strides=_nx.zeros_like(shape)) self._it = _nx.nditer(x, flags=['multi_index', 'zerosize_ok'], order='C')
def windowed_view(arr, window, overlap): from numpy.lib.stride_tricks import as_strided arr = np.asarray(arr) window_step = window - overlap new_shape = arr.shape[:-1] + ((arr.shape[-1] - overlap) // window_step, window) new_strides = (arr.strides[:-1] + (window_step * arr.strides[-1],) + arr.strides[-1:]) return as_strided(arr, shape=new_shape, strides=new_strides)
def repeat_last_axis(array, count): """ Restride `array` to repeat `count` times along the last axis. Parameters ---------- array : np.array The array to restride. count : int Number of times to repeat `array`. Returns ------- result : array Array of shape array.shape + (count,) composed of `array` repeated `count` times along the last axis. Example ------- >>> from numpy import arange >>> a = arange(3); a array([0, 1, 2]) >>> repeat_last_axis(a, 2) array([[0, 0], [1, 1], [2, 2]]) >>> repeat_last_axis(a, 4) array([[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 2, 2]]) Notes ---- The resulting array will share memory with `array`. If you need to assign to the input or output, you should probably make a copy first. See Also -------- repeat_last_axis """ return as_strided(array, array.shape + (count,), array.strides + (0,))
def rolling_window(X, window_size): # for 1d data shape = X.shape[:-1] + (X.shape[-1] - window_size + 1, window_size) strides = X.strides + (X.strides[-1],) return np.lib.stride_tricks.as_strided(X, shape=shape, strides=strides)
def overlap(X, window_size, window_step): """ Create an overlapped version of X Parameters ---------- X : ndarray, shape=(n_samples,) Input signal to window and overlap window_size : int Size of windows to take window_step : int Step size between windows Returns ------- X_strided : shape=(n_windows, window_size) 2D array of overlapped X """ if window_size % 2 != 0: raise ValueError("Window size must be even!") # Make sure there are an even number of windows before stridetricks append = np.zeros((window_size - len(X) % window_size)) X = np.hstack((X, append)) overlap_sz = window_size - window_step new_shape = X.shape[:-1] + ((X.shape[-1] - overlap_sz) // window_step, window_size) new_strides = X.strides[:-1] + (window_step * X.strides[-1],) + X.strides[-1:] X_strided = as_strided(X, shape=new_shape, strides=new_strides) return X_strided
def halfoverlap(X, window_size): """ Create an overlapped version of X using 50% of window_size as overlap. Parameters ---------- X : ndarray, shape=(n_samples,) Input signal to window and overlap window_size : int Size of windows to take Returns ------- X_strided : shape=(n_windows, window_size) 2D array of overlapped X """ if window_size % 2 != 0: raise ValueError("Window size must be even!") window_step = window_size // 2 # Make sure there are an even number of windows before stridetricks append = np.zeros((window_size - len(X) % window_size)) X = np.hstack((X, append)) num_frames = len(X) // window_step - 1 row_stride = X.itemsize * window_step col_stride = X.itemsize X_strided = as_strided(X, shape=(num_frames, window_size), strides=(row_stride, col_stride)) return X_strided
