// a single channel, so `C = 1`. Note that `C` is almost always `1`, for input
// Tensors as this axis indexes the different scattering coefficients.
x = torch.from_numpy(x).float()
x /= x.abs().max()
x = x.view(1, -1)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// We are now ready to set up the parameters for the scattering transform.
// First, the number of samples, `T`, is given by the size of our input `x`.
// The averaging scale is specified as a power of two, `2**J`. Here, we set
// `J = 6` to get an averaging, or maximum, scattering scale of `2**6 = 64`
// samples. Finally, we set the number of wavelets per octave, `Q`, to `16`.
// This lets us resolve frequencies at a resolution of `1/16` octaves.
T = x.shape[-1]
J = 6
Q = 16
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Finally, we are able to create the object which computes our scattering
// transform, `scattering`.
scattering = Scattering1D(J, T, Q)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Compute and display the scattering coefficients
// -----------------------------------------------
// Computing the scattering transform of a PyTorch Tensor is achieved using the
// `forward()` method of the `Scattering1D` class. The output is another Tensor
// of shape `(B, C, T)`. Here, `B` is the same as for the input `x`, but `C` is
// the number of scattering coefficient outputs, and `T` is the number of
// samples along the time axis. This is typically much smaller than the number
// of input samples since the scattering transform performs an average in time
// and subsamples the result to save memory.
Sx = scattering.forward(x)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// To display the scattering coefficients, we must first identify which belong
// to each order (zeroth, first, or second). We do this by extracting the `meta`
// information from the scattering object and constructing masks for each order.
meta = Scattering1D.compute_meta_scattering(J, Q)
order0 = (meta["order"] == 0)
order1 = (meta["order"] == 1)
order2 = (meta["order"] == 2)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// First, we plot the original signal `x`. Note that we have to index it as
// `x[0,0,:]` to convert it to a one-dimensional array and convert it to a
// numpy array using the `numpy()` method.
plt.figure(figsize=(8, 2))
plt.plot(x[0,:].numpy())
plt.title("Original signal")
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
After Change
// numpy array using the `numpy()` method.
plt.figure(figsize=(8, 2))
plt.plot(np.squeeze(x))
plt.title("Original signal")
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
