FFTConvolve

class auglib.transform.FFTConvolve(aux, *, keep_tail=True, transform=None, preserve_level=False, bypass_prob=None)

Convolve signal with another signal.

The convolution is done by a FFT-based approach.

Parameters:

• aux (str | auglib.core.observe.Base | numpy.ndarray | auglib.core.transform.Base) – auxiliary signal, file, or signal generating transform. If a transform is given it will be applied to an empty signal with the same length as the base signal

• keep_tail (bool | auglib.core.observe.Base) – keep the tail of the convolution result (extending the length of the signal), or to cut it out (keeping the original length of the input)

• transform (auglib.core.transform.Base) – transformation applied to the auxiliary signal

• preserve_level (bool | auglib.core.observe.Base) – if True the root mean square value of the augmented signal will be the same as before augmentation

• bypass_prob (float | auglib.core.observe.Base) – probability to bypass the transformation

Examples

Filter a speech signal by a Telefunken M201/1 microphone.

>>> import audb
>>> import audiofile
>>> import audplot
>>> import auglib
>>> files = audb.load_media(
...     "micirp",
...     "dirs/Telefunken_M201.wav",
...     version="1.0.0",
...     sampling_rate=16000,
... )
>>> transform = auglib.transform.FFTConvolve(files[0])
>>> files = audb.load_media("emodb", "wav/03a01Fa.wav", version="1.4.1")
>>> signal, _ = audiofile.read(files[0])
>>> augmented_signal = transform(signal)
>>> audplot.waveform(augmented_signal)

Inspect its magnitude spectrum.

>>> import audmath
>>> import matplotlib.pyplot as plt
>>> import seaborn as sns
>>> sigs = [signal, augmented_signal]
>>> colors = ["#5d6370", "#e13b41"]
>>> for sig, color in zip(sigs, colors):
...     magnitude, f = plt.mlab.magnitude_spectrum(sig, Fs=sampling_rate)
...     # Smooth magnitude
...     magnitude = np.convolve(magnitude, np.ones(14) / 14, mode="same")
...     plt.plot(f, audmath.db(magnitude), color=color)
>>> plt.xlim([10, 8000])
>>> plt.ylim([-100, -45])
>>> plt.ylabel("Magnitude / dB")
>>> plt.xlabel("Frequency / Hz")
>>> plt.legend(["signal", "augmented signal"])
>>> plt.grid(alpha=0.4)
>>> sns.despine()
>>> plt.tight_layout()

__call__()

FFTConvolve.__call__(signal, sampling_rate=None)

Apply transform to signal.

Parameters:

• signal (numpy.ndarray) – signal to be transformed

• sampling_rate (int) – sampling rate in Hz

Return type:

numpy.ndarray

Returns:

augmented signal

Raises:

• ValueError – if the signal shape is not support by chosen transform parameters

• ValueError – if sampling_rate is None, but the transform requires a sampling rate

• RuntimeError – if the given sampling rate is incompatible with the transform

arguments

FFTConvolve.arguments

Returns arguments that are serialized.

Returns:

Dictionary of arguments and their values.

Raises:

RuntimeError – if arguments are found that are not assigned to attributes of the same name

Examples

>>> import audobject.testing
>>> o = audobject.testing.TestObject("test", point=(1, 1))
>>> o.arguments
{'name': 'test', 'point': (1, 1)}

borrowed_arguments

FFTConvolve.borrowed_arguments

Returns borrowed arguments.

Returns:

Dictionary with borrowed arguments.

from_dict()

static FFTConvolve.from_dict(d, root=None, **kwargs)

Return type:

audobject.core.object.Object

from_yaml()

static FFTConvolve.from_yaml(path_or_stream, **kwargs)

Return type:

audobject.core.object.Object

from_yaml_s()

static FFTConvolve.from_yaml_s(yaml_string, **kwargs)

Return type:

audobject.core.object.Object

hidden_arguments

FFTConvolve.hidden_arguments

Returns hidden arguments.

Returns:

List with names of hidden arguments.

id

FFTConvolve.id

Object identifier.

The ID of an object ID is created from its non-hidden arguments.

Returns:

object identifier

Examples

>>> class Foo(Object):
...     def __init__(self, bar: str):
...         self.bar = bar
>>> foo1 = Foo("I am unique!")
>>> foo1.id
'893df240-babe-d796-cdf1-c436171b7a96'
>>> foo2 = Foo("I am different!")
>>> foo2.id
'9303f2a5-bfc9-e5ff-0ffa-a9846e2d2190'
>>> foo3 = Foo("I am unique!")
>>> foo1.id == foo3.id
True

is_loaded_from_dict

FFTConvolve.is_loaded_from_dict

Check if object was loaded from a dictionary.

Returns True if object was initialized from a dictionary, e.g. after loading it from a YAML file.

Returns:

True if object was loaded from a dictionary,

otherwise False

resolvers

FFTConvolve.resolvers

Return resolvers.

Returns:

Dictionary with resolvers.

short_id

FFTConvolve.short_id

Short object identifier.

The short ID consists of eight characters and is created from its non-hidden arguments.

Returns:

short object identifier

Examples

>>> class Foo(Object):
...     def __init__(self, bar: str):
...         self.bar = bar
>>> foo1 = Foo("I am unique!")
>>> foo1.id
'893df240-babe-d796-cdf1-c436171b7a96'
>>> foo1.short_id
'171b7a96'
>>> foo2 = Foo("I am different!")
>>> foo2.short_id
'6e2d2190'
>>> foo3 = Foo("I am unique!")
>>> foo1.short_id == foo3.short_id
True

to_dict()

FFTConvolve.to_dict(*, include_version=True, flatten=False, root=None)

Converts object to a dictionary.

Includes items from audobject.Object.arguments. If an argument has a resolver, its value is encoded. Usually, the object can be re-instantiated using audobject.Object.from_dict(). However, if flatten=True, this is not possible.

Parameters:

• include_version (bool) – add version to class name

• flatten (bool) – flatten the dictionary

• root (str) – if file is written to disk, set to target directory

Return type:

collections.abc.Mapping[str, typing.Union[bool, datetime.datetime, dict, float, int, list, None, str]]

Returns:

dictionary that represent the object

Examples

>>> import audobject.testing
>>> o = audobject.testing.TestObject("test", point=(1, 1))
>>> o.to_dict(include_version=False)
{'$audobject.core.testing.TestObject': {'name': 'test', 'point': [1, 1]}}
>>> o.to_dict(flatten=True)
{'name': 'test', 'point.0': 1, 'point.1': 1}

to_samples()

FFTConvolve.to_samples(value, sampling_rate=None, *, length=None, allow_negative=True)

Convert duration value to samples.

Return type:

int

to_yaml()

FFTConvolve.to_yaml(path_or_stream, *, include_version=True)

Save object to YAML file.

Parameters:

• path_or_stream (str | io.IOBase) – file path or stream

• include_version (bool) – add version to class name

to_yaml_s()

FFTConvolve.to_yaml_s(*, include_version=True)

Convert object to YAML string.

Parameters:

include_version (bool) – add version to class name

Return type:

str

Returns:

YAML string

Examples

>>> import audobject.testing
>>> o = audobject.testing.TestObject("test", point=(1, 1))
>>> print(o.to_yaml_s(include_version=False))
$audobject.core.testing.TestObject:
  name: test
  point:
  - 1
  - 1