windowing = zounds.HalfLapped() # Segment audio files ######################################################### class Settings(ff.PersistenceSettings): id_provider = ff.UserSpecifiedIdProvider(key='_id') key_builder = ff.StringDelimitedKeyBuilder(seperator='|') database = ff.LmdbDatabase(path='onsetdata', key_builder=key_builder) event_log = ff.EventLog( path='onsetdataevents', channel=ff.InMemoryChannel()) STFT = zounds.stft( resample_to=zounds.SR11025(), wscheme=windowing) class WithOnsets(STFT, Settings): bark = zounds.ArrayWithUnitsFeature( zounds.BarkBands, needs=STFT.fft, store=True) transience = zounds.ArrayWithUnitsFeature( zounds.MeasureOfTransience, needs=STFT.fft, store=True) sliding_detection = zounds.ArrayWithUnitsFeature(
import zounds import argparse samplerate = zounds.SR11025() BaseModel = zounds.stft(resample_to=samplerate, store_fft=True) @zounds.simple_in_memory_settings class Sound(BaseModel): pass if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument( '--local-path', required=True, type=str, help='local path where the nsynth tar files should be stored') parser.add_argument( '--port', default=8888, type=int, help='port to run the in-browser REPL in') args = parser.parse_args() ns = zounds.NSynth(path=args.local_path) zounds.ingest(ns, Sound, multi_threaded=True) app = zounds.ZoundsApp( model=Sound,
""" Demonstrate how to download and process sounds from https://freesound.org """ import zounds import argparse BaseModel = zounds.stft(resample_to=zounds.SR11025()) @zounds.simple_lmdb_settings('freesound', map_size=1e10, user_supplied_id=True) class Sound(BaseModel): bark = zounds.ArrayWithUnitsFeature(zounds.BarkBands, needs=BaseModel.fft, store=True) chroma = zounds.ArrayWithUnitsFeature(zounds.Chroma, needs=BaseModel.fft, store=True) if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument( '--api-key', help='your Freesound API key (http://freesound.org/apiv2/apply/)', type=str, required=True) parser.add_argument('--query', help='the text query to run against freesound', type=str,
import zounds samplerate = zounds.SR22050() BaseModel = zounds.stft(resample_to=samplerate, store_fft=True) @zounds.simple_in_memory_settings class Sound(BaseModel): pass if __name__ == '__main__': url = 'https://ia802606.us.archive.org/9/items/AOC11B/onclassical_luisi_bach_partita_e-minor_bwv-830_3.ogg' _id = Sound.process(meta=url) snd = Sound(_id) band = zounds.FrequencyBand(50, samplerate.nyquist) bark_scale = zounds.BarkScale(band, 100) mel_scale = zounds.MelScale(band, 100) chroma_scale = zounds.ChromaScale(band) bark_bands = bark_scale.apply(snd.fft, zounds.HanningWindowingFunc()) mel_bands = mel_scale.apply(snd.fft, zounds.HanningWindowingFunc()) chroma_bands = chroma_scale.apply(snd.fft, zounds.HanningWindowingFunc()) app = zounds.ZoundsApp( model=Sound, visualization_feature=Sound.fft, audio_feature=Sound.ogg, globals=globals(), locals=locals())
""" Demonstrate an extremely simple audio encoder that learns basis functions for individual audio frames from a corpus of data """ import featureflow as ff import zounds from random import choice samplerate = zounds.SR11025() STFT = zounds.stft(resample_to=samplerate) class Settings(ff.PersistenceSettings): """ These settings make it possible to specify an id (rather than automatically generating one) when analyzing a file, so that it's easier to reference them later. """ id_provider = ff.UserSpecifiedIdProvider(key='_id') key_builder = ff.StringDelimitedKeyBuilder() database = ff.LmdbDatabase( 'mdct_synth', map_size=1e10, key_builder=key_builder) class Document(STFT, Settings): """ Inherit from a basic processing graph, and add a Modified Discrete Cosine Transform feature """ mdct = zounds.ArrayWithUnitsFeature(
import zounds from zounds.spectral import time_stretch, pitch_shift from zounds.ui import AppSettings import argparse sr = zounds.SR11025() BaseModel = zounds.stft(resample_to=sr, store_resampled=True) @zounds.simple_in_memory_settings class Sound(BaseModel): pass if __name__ == '__main__': parser = argparse.ArgumentParser(parents=[AppSettings()]) parser.add_argument( '--sound-uri', default= 'https://archive.org/download/LucaBrasi2/06-Kevin_Gates-Out_The_Mud_Prod_By_The_Runners_The_Monarch.ogg' ) args = parser.parse_args() _id = Sound.process(meta=args.sound_uri) snd = Sound(_id) original = snd.resampled slow = zounds.AudioSamples(time_stretch(original, 0.75).squeeze(), sr) fast = zounds.AudioSamples(time_stretch(original, 1.25).squeeze(), sr) higher = zounds.AudioSamples(pitch_shift(original, 1.0).squeeze(), sr)
""" Demonstrate how to build a hamming-distance index over a binary/bit-packed feature. This example is particularly handy for performance profiling of the hamming index. """ import zounds import numpy as np samplerate = zounds.SR11025() BaseModel = zounds.stft(resample_to=samplerate, store_resampled=False) def produce_fake_hash(x): """ Produce random, binary features, totally irrespective of the content of x, but in the same shape as x. """ h = np.random.binomial(1, 0.5, (x.shape[0], 1024)) packed = np.packbits(h, axis=-1).view(np.uint64) return zounds.ArrayWithUnits( packed, [x.dimensions[0], zounds.IdentityDimension()]) @zounds.simple_lmdb_settings( 'hamming_index', map_size=1e11, user_supplied_id=True) class Sound(BaseModel): fake_hash = zounds.ArrayWithUnitsFeature(
""" Demonstrate how to download and process sounds from https://freesound.org """ import zounds import argparse BaseModel = zounds.stft(resample_to=zounds.SR11025()) @zounds.simple_lmdb_settings('freesound', map_size=1e10, user_supplied_id=True) class Sound(BaseModel): bark = zounds.ArrayWithUnitsFeature( zounds.BarkBands, needs=BaseModel.fft, store=True) chroma = zounds.ArrayWithUnitsFeature( zounds.Chroma, needs=BaseModel.fft, store=True) if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument( '--api-key', help='your Freesound API key (http://freesound.org/apiv2/apply/)', type=str, required=True) parser.add_argument(
import argparse import featureflow as ff import zounds class Settings(ff.PersistenceSettings): id_provider = ff.UuidProvider() key_builder = ff.StringDelimitedKeyBuilder() database = ff.LmdbDatabase(path='timbre', key_builder=key_builder) windowing = zounds.HalfLapped() STFT = zounds.stft(resample_to=zounds.SR22050(), wscheme=windowing) class WithTimbre(STFT, Settings): bark = zounds.ConstantRateTimeSeriesFeature( zounds.BarkBands, needs=STFT.fft, store=True) bfcc = zounds.ConstantRateTimeSeriesFeature( zounds.BFCC, needs=bark, store=True) @zounds.simple_settings class BfccKmeans(ff.BaseModel): docs = ff.Feature( ff.IteratorNode,
import zounds from zounds.spectral import time_stretch, pitch_shift from zounds.ui import AppSettings import argparse sr = zounds.SR11025() BaseModel = zounds.stft(resample_to=sr, store_resampled=True) @zounds.simple_in_memory_settings class Sound(BaseModel): pass if __name__ == '__main__': parser = argparse.ArgumentParser(parents=[ AppSettings() ]) parser.add_argument( '--sound-uri', default='https://archive.org/download/LucaBrasi2/06-Kevin_Gates-Out_The_Mud_Prod_By_The_Runners_The_Monarch.ogg') args = parser.parse_args() _id = Sound.process(meta=args.sound_uri) snd = Sound(_id) original = snd.resampled slow = zounds.AudioSamples(time_stretch(original, 0.75).squeeze(), sr) fast = zounds.AudioSamples(time_stretch(original, 1.25).squeeze(), sr) higher = zounds.AudioSamples(pitch_shift(original, 1.0).squeeze(), sr)
This implementation differs in that it does not use the MDCT transform on the frequency domain, as getting the overlaps just right, such that they satisfy MDCT invertibility requirements, is tricky, and requires some low level knowledge that zounds' Scale attempts to abstract away. See section 3.3 Setting MDCT Sizes for information about what we're fudging/ glossing over in this implementation. We instead use the DCT2 transform, which makes inversion easier, at the cost of more redundancy. """ from __future__ import division import zounds import scipy samplerate = zounds.SR11025() BaseModel = zounds.stft(resample_to=samplerate) windowing_func = zounds.OggVorbisWindowingFunc() scale = zounds.GeometricScale(300, 3030, 0.05, 100) @zounds.simple_in_memory_settings class Document(BaseModel): bark = zounds.ArrayWithUnitsFeature(zounds.BarkBands, samplerate=samplerate, stop_freq_hz=samplerate.nyquist, needs=BaseModel.fft, store=True) long_windowed = zounds.ArrayWithUnitsFeature(
""" Demonstrate how to build a hamming-distance index over a binary/bit-packed feature. This example is particularly handy for performance profiling of the hamming index. """ import zounds import numpy as np samplerate = zounds.SR11025() BaseModel = zounds.stft(resample_to=samplerate, store_resampled=False) def produce_fake_hash(x): """ Produce random, binary features, totally irrespective of the content of x, but in the same shape as x. """ h = np.random.binomial(1, 0.5, (x.shape[0], 1024)) packed = np.packbits(h, axis=-1).view(np.uint64) return zounds.ArrayWithUnits( packed, [x.dimensions[0], zounds.IdentityDimension()]) @zounds.simple_lmdb_settings('hamming_index', map_size=1e11, user_supplied_id=True) class Sound(BaseModel):
This implementation differs in that it does not use the MDCT transform on the frequency domain, as getting the overlaps just right, such that they satisfy MDCT invertibility requirements, is tricky, and requires some low level knowledge that zounds' Scale attempts to abstract away. See section 3.3 Setting MDCT Sizes for information about what we're fudging/ glossing over in this implementation. We instead use the DCT2 transform, which makes inversion easier, at the cost of more redundancy. """ import zounds import scipy samplerate = zounds.SR11025() BaseModel = zounds.stft(resample_to=samplerate) windowing_func = zounds.OggVorbisWindowingFunc() scale = zounds.GeometricScale(300, 3030, 0.05, 100) @zounds.simple_in_memory_settings class Document(BaseModel): bark = zounds.ArrayWithUnitsFeature( zounds.BarkBands, samplerate=samplerate, stop_freq_hz=samplerate.nyquist, needs=BaseModel.fft, store=True)