dcase_util教程（二）——各单元介绍

class Multiplier(dcase_util.containers.ObjectContainer):
    def __init__(self, multiplier=None, **kwargs):
        super(Multiplier, self).__init__(**kwargs)
        self.multiplier = multiplier

    def __str__(self):
        ui = dcase_util.ui.FancyStringifier()
        output = super(Multiplier, self).__str__()
        output+= ui.data(field='multiplier', value=self.multiplier)
        return output

    def multiply(self, data):
        return self.multiplier * data

m = Multiplier(10)
m.show()
# Multiplier :: Class
#   multiplier                        : 10

print(m.multiply(5))
# 50

# Save object
m.save('test.cpickle')

# Load object
m2 = Multiplier().load('test.cpickle')

print(m2.multiply(5))
# 50

m2.show()
# Multiplier :: Class
#   filename                          : test.cpickle
#   multiplier                        : 10

import dcase_util

d = dcase_util.containers.DictContainer(
    {
        'test': {
            'field1': 1,
            'field2': 2,
        },
        'test2': 100
    }
)
d.show()
# DictContainer
#   test
#     field1                          : 1
#     field2                          : 2
#   test2                             : 100

print(d.get_path('test.field1'))
# 1

print(d.get_path(['test', 'field1']))
# 1

print(d.get_path('test2'))
# 100

d.set_path('test.field2', 200)
print(d.get_path('test.field2'))
# 200

print(d.get_leaf_path_list())
# ['test.field1', 'test.field2', 'test2']

print(d.get_leaf_path_list(target_field_startswith='field'))
# ['test.field1', 'test.field2']

d.show()
# DictContainer
#   test
#     field1                          : 1
#     field2                          : 200
#   test2                             : 100

import dcase_util
ld = dcase_util.containers.ListDictContainer(
    [
        {
            'field1': 1,
            'field2': 2,
        },
        {
            'field1': 3,
            'field2': 4,
        },
    ]
)
ld.show()
# ListDictContainer
# [0] =======================================
#    DictContainer
#      field1                            : 1
#      field2                            : 2
#
# [1] =======================================
#    DictContainer
#      field1                            : 3
#      field2                            : 4

print(ld.search(key='field1', value=3))
# DictContainer
#   field1                            : 3
#   field2                            : 4

print(ld.get_field(field_name='field2'))
# [2, 4]

# Initialize container with random matrix 10x100, and set time resolution to 20ms
data_container = dcase_util.containers.DataMatrix2DContainer(
  data=numpy.random.rand(10,100),
  time_resolution=0.02
)

# When storing, e.g., acoustic features, time resolution corresponds to feature extraction frame hop length.

# Access data matrix directly
print(data_container.data.shape)
# (10, 100)

# Show container information
data_container.show()
# DataMatrix2DContainer :: Class
#   Data
#     data                            : matrix (10,100)
#     Dimensions
#       time_axis                     : 1
#       data_axis                     : 0
#     Timing information
#       time_resolution               : 0.02 sec
#   Meta
#     stats                           : Calculated
#     metadata                        : -
#     processing_chain                : -
#   Duration
#       Frames                        : 100
#       Seconds                       : 2.00 sec

# Using focus to get part data between 0.5 sec and 1.0 sec
print(data_container.set_focus(start_seconds=0.5, stop_seconds=1.0).get_focused().shape)
# (10, 25)

# Using focus to get part data between frame 10 and 50
print(data_container.set_focus(start=10, stop=50).get_focused().shape)
# (10, 40)

# Resetting focus and accessing full data matrix
data_container.reset_focus()
print(data_container.get_focused().shape)
# (10, 100)

# Access frames 1, 2, 10, and 30
data_container.get_frames(frame_ids=[1,2,10,30])

# Access frames 1-5, and only first value per column
data_container.get_frames(frame_ids=[1,2,3,4,5], vector_ids=[0])

# Transpose matrix
transposed_data = data_container.T
print(transposed_data.shape)
# (100, 10)

# Plot data
data_container.plot()

# Initialize container with data
data_repository = dcase_util.containers.DataRepository(
    data={
        'label1': {
            'stream0': {
                'data': 100
            },
            'stream1': {
                'data': 200
            }
        },
        'label2': {
            'stream0': {
                'data': 300
            },
            'stream1': {
                'data': 400
            }
        }
    }
)
# Show container information::
data_repository. show()
# DataRepository :: Class
#     Repository info
#       Item class                    : DataMatrix2DContainer
#       Item count                    : 2
#       Labels                        : ['label1', 'label2']
#     Content
#       [label1][stream1]             : {'data': 200}
#       [label1][stream0]             : {'data': 100}
#       [label2][stream1]             : {'data': 400}
#       [label2][stream0]             : {'data': 300}

# Accessing data inside repository
data_repository.get_container(label='label1',stream_id='stream1')
# {'data': 200}

# Setting data
data_repository.set_container(label='label3',stream_id='stream0', container={'data':500})
data_repository. show()
# DataRepository :: Class
#     Repository info
#       Item class                    : DataMatrix2DContainer
#       Item count                    : 3
#       Labels                        : ['label1', 'label2', 'label3']
#     Content
#       [label1][stream1]             : {'data': 200}
#       [label1][stream0]             : {'data': 100}
#       [label2][stream1]             : {'data': 400}
#       [label2][stream0]             : {'data': 300}
#       [label3][stream0]             : {'data': 500}

# Generating two-channel audio
audio_container = dcase_util.containers.AudioContainer(fs=44100)
t = numpy.linspace(0, 2, 2 * audio_container.fs, endpoint=False)
x1 = numpy.sin(220 * 2 * numpy.pi * t)
x2 = numpy.sin(440 * 2 * numpy.pi * t)
audio_container.data = numpy.vstack([x1, x2])

audio_container.show()
# AudioContainer :: Class
#  Sampling rate                     : 44100
#     Channels                        : 2
#   Duration
#     Seconds                         : 2.00 sec
#     Milliseconds                    : 2000.00 ms
#     Samples                         : 88200 samples

# Loading audio file
audio_container = dcase_util.containers.AudioContainer().load(
  filename=dcase_util.utils.Example.audio_filename()
)

# Loading audio content from Youtube
audio_container = dcase_util.containers.AudioContainer().load_from_youtube(
  query_id='2ceUOv8A3FE',
  start=1,
  stop=5
)

# Using focus to get part data between 0.5 sec and 1.0 sec
print(audio_container.set_focus(start_seconds=0.5, stop_seconds=1.0).get_focused().shape)
# (2, 22050)

# Using focus to get part data starting 5 sec with 2 sec duration
print(audio_container.set_focus(start_seconds=5, duration_seconds=2.0).get_focused().shape)
# (2, 88200)

# Using focus to get part data starting 5 sec with 2 sec duration, mixdown of two stereo channels
print(audio_container.set_focus(start_seconds=5, duration_seconds=2.0, channel='mixdown').get_focused().shape)
# (88200,)

# Using focus to get part data starting 5 sec with 2 sec duration, left of two stereo channels
print(audio_container.set_focus(start_seconds=5, duration_seconds=2.0, channel='left').get_focused().shape)
# (88200,)

# Using focus to get part data starting 5 sec with 2 sec duration, seconds audio channel (indexing starts from 0)
print(audio_container.set_focus(start_seconds=5, duration_seconds=2.0, channel=1).get_focused().shape)
# (88200,)

# Using focus to get part data between samples 44100 and 88200
print(audio_container.set_focus(start=44100, stop=88200).get_focused().shape)
# (2, 44100)

# Resetting focus and accessing full data matrix::
audio_container.reset_focus()
print(audio_container.get_focused().shape)
# (2, 441001)

# Using focus to get part data starting 5 sec with 2 sec duration, and freeze this segment ::
audio_container.set_focus(start_seconds=5, duration_seconds=2.0).freeze()
print(audio_container.shape)
# (2, 88200)

# Normalizing audio
audio_container.normalize()

# Resampling audio to target sampling rate
audio_container.resample(target_fs=16000)

# Plotting waveform
audio_container.plot_wave()

# Plotting spectrogram
audio_container.plot_spec()

data_aggregator = dcase_util.data.Aggregator(
    recipe=['mean', 'std'],
    win_length_frames=10,
    hop_length_frames=1,
)

data_stacker = dcase_util.data.Stacker(recipe='mfcc')
data_repository = dcase_util.utils.Example.feature_repository()
data_matrix = data_stacker.stack(data_repository)
data_matrix = data_aggregator.aggregate(data_matrix)

[
 {
    'method': 'mfcc',
 },
 {
    'method': 'mfcc_delta'
    'vector-index: {
        'channel': 0,
        'start': 1,
        'end': 17,
        'full': False,
        'selection': False,
    }
  },
 {
    'method': 'mfcc_acceleration',
    'vector-index: {
        'channel': 0,
        'full': False,
        'selection': True,
        'vector': [2, 4, 6]
    }
 }
]

# Create class
dataset = dcase_util.datasets.TUTAcousticScenes_2017_DevelopmentSet(data_path='data')
# Initialize dataset, this will make sure dataset is downloaded, packages are extracted,
# and needed meta files are created
dataset.initialize()
# Show meta data
dataset.meta.show()
# Get all evaluation setup folds
folds = dataset.folds()
# Get all evaluation setup folds
train_data_fold1 = dataset.train(fold=folds[0])
test_data_fold1 = dataset.test(fold=folds[0])

class dcase_util.features.FeatureExtractor(fs=44100, win_length_samples=None, hop_length_samples=None, win_length_seconds=0.04, hop_length_seconds=0.02, **kwargs)

epochs = 100
batch_size = 256
loss = 'categorical_crossentropy'
metrics =  ['categorical_accuracy']
processing_interval = 1
manual_update = True
external_metric_labels={'ER': 'Error rate'}

callback_list = [
        dcase_util.keras.ProgressLoggerCallback(
            epochs=epochs,
            metric=metrics,
            loss=loss,
            manual_update=manual_update,
            manual_update_interval=processing_interval,
            external_metric_labels=external_metric_labels
        ),
        dcase_util.keras.ProgressPlotterCallback(
            epochs=epochs,
            metric=metrics,
            save=False,
            manual_update=manual_update,
            manual_update_interval=processing_interval,
            external_metric_labels=external_metric_labels
        ),
        dcase_util.keras.StopperCallback(
            epochs=epochs,
            monitor=metric[0],
            manual_update=manual_update,
        ),
        dcase_util.keras.StasherCallback(
            epochs=epochs,
            monitor=metric[0],
            manual_update=manual_update,
        )
    ]

for epoch_start in range(0, epochs, processing_interval):
    epoch_end = epoch_start + processing_interval

    # Make sure we have only specified amount of epochs
    if epoch_end > epochs:
        epoch_end = epochs

    # Train model
    keras_model.fit(
        x=training_X,
        y=training_Y,
        validation_data=(validation_X, validation_Y),
        callbacks=callback_list,
        verbose=0,
        initial_epoch=epoch_start,
        epochs=epoch_end,
        batch_size=batch_size,
        shuffle=True
    )
    # Calculate external metrics
    ER = 0.0

    # Inject external metric values to the callbacks
    for callback in callback_list:
        if hasattr(callback, 'set_external_metric_value'):
            callback.set_external_metric_value(
                metric_label='ER',
                metric_value=ER
            )

    # Manually update callbacks
    for callback in callback_list:
        if hasattr(callback, 'update'):
            callback.update()

    # Check we need to stop training
    stop_training = False
    for callback in callback_list:
        if hasattr(callback, 'stop'):
            if callback.stop():
                stop_training = True

    if stop_training:
        # Stop the training loop
        break

ui = dcase_util.ui.FancyLogger()
ui.title('title')
ui.section_header('section_header')
ui.sub_header('sub_header')
ui.foot('foot')
ui.line('line', indent=2)
ui.line('line', indent=4)
ui.line('line', indent=6)

# Data row with field and value
ui.data('data field', 'value', 'unit')

# Horizontal separator
ui.sep()

# Table
ui.table(cell_data=[[1, 2, 3], [1, 2, 3]])

# Faster way to create output tables without collecting data into one data structure.
ui.row('Header1', 'Header2', widths=[10,20], types=['float2','str20'])
ui.row('-','-')
ui.row(10.21231, 'String text')

[I] title
[I] section_header
[I] ========================================
[I] === sub_header ===
[I]   foot
[I]
[I]   line
[I]     line
[I]       line
[I]   data field                        : value unit
[I] ========================================
[I] Col #0   Col #1
[I] ------   ------
[I]      1        1
[I]      2        2
[I]      3        3
[I]
[I]   Header1 | Header2           |
[I]   ------- | ----------------- |
[I]    10.21  | String text       |

ui = dcase_util.ui.FancyPrinter()
ui.title('title')
ui.section_header('section_header')
ui.sub_header('sub_header')
ui.foot('foot')
ui.line('line', indent=2)
ui.line('line', indent=4)
ui.line('line', indent=6)

# Data row with field and value
ui.data('data field', 'value', 'unit')

# Horizontal separator
ui.sep()

# Table
ui.table(cell_data=[[1, 2, 3], [1, 2, 3]])

# Faster way to create output tables without collecting data into one data structure.
ui.row('Header1', 'Header2', widths=[10,20], types=['float2','str20'])
ui.row('-','-')
ui.row(10.21231, 'String text')

title
section_header
========================================
=== sub_header ===
  foot

  line
    line
      line
  data field                        : value unit
========================================
Col #0   Col #1
------   ------
     1        1
     2        2
     3        3

  Header1 | Header2           |
  ------- | ----------------- |
   10.21  | String text       |