dcase_util教程（二）——各单元介绍-CSDN博客

接着上一篇教程，继续的有各个UTILITIES的介绍。网址

1. Container

数据容器的类。这些数据的目的是为了包装数据，使用有用的方法来访问和操作数据，以及加载和存储数据。

这些容器是从标准的Python容器（例如对象，列表和字典）继承的，以使它们可以与其他工具和库一起使用。

1.1 Basic containers

ObjectContainer

dcase_util.containers.ObjectContainer，从标准对象类继承的对象的容器类。

调用格式	功能
`ObjectContainer(\args, \\*kwargs)`	从标准对象类继承的对象的容器类。
`ObjectContainer.load([filename])`	加载文件
`ObjectContainer.save([filename])`	保存文件
`ObjectContainer.show()`	打印容器内容
`ObjectContainer.log([level])`	日志容器内容

示例如何从ObjectContainer继承类：

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

1.1.1 DictContainer

dcase_util.containers.DictContainer字典容器类继承自标准的字典类。

调用格式	功能
`DictContainer(\args, \\*kwargs)`	字典从标准dict类继承的容器类。
`DictContainer.load([filename])`	加载文件
`DictContainer.save([filename])`	保存文件
`DictContainer.show()`	打印容器内容
`DictContainer.log([level])`	日志容器内容
`DictContainer.get_path(path[, default, data])`	从带嵌入字典的路径中获取值
`DictContainer.set_path(path, new_value[, data])`	使用点路径（dotted path）在嵌套字典中设置值
`DictContainer.get_leaf_path_list([...])`	获取路径列表到嵌套字典中的所有叶节点。
`DictContainer.merge(override[, target])`	递归字典合并
`DictContainer.get_hash_for_path([dotted_path])`	在给定路径下获取数据的唯一哈希字符串。
`DictContainer.get_hash([data])`	获取给定参数字典的唯一哈希字符串（md5）。

用法示例：

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

1.1.2 ListContainer

dcase_util.containers.ListContainer，列表容器从标准列表类继承的容器类。

调用格式	功能
`ListContainer(\args, \\*kwargs)`	字典从标准dict类继承的容器类。
`ListContainer.load([filename, headers])`	加载文件
`ListContainer.save([filename])`	保存文件
`ListContainer.show()`	打印容器内容
`ListContainer.log([level])`	日志容器内容
`ListContainer.update(data)`	用给定列表替换内容

1.1.3 ListDictContainer

dcase_util.containers.ListDictContainer，从标准列表类继承的字典列表容器类。

调用格式	功能
`ListDictContainer(\args, \\*kwargs)`	字典列表从标准dict类继承的容器类。
`ListDictContainer.load([filename, fields, ...])`	加载文件
`ListDictContainer.save([filename, fields, ...])`	保存文件
`ListDictContainer.show()`	打印容器内容
`ListDictContainer.log([level])`	日志容器内容
`ListDictContainer.search(key, value)`	在字典列表中搜索
`ListDictContainer.get_field(field_name[, ...])`	从字段获取所有数据

用法示例：

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]

1.1.4 RepositoryContainer

dcase_util.containers.RepositoryContainer，存储库的容器类，从dcase_util.containers.DictContainer继承。

调用格式	功能
`RepositoryContainer(\args, \\*kwargs)`	从DictContainer继承的存储库的容器类。
`RepositoryContainer.load([filename])`	加载文件
`RepositoryContainer.save([filename])`	保存文件
`RepositoryContainer.show()`	打印容器内容
`RepositoryContainer.log([level])`	日志容器内容

1.1.5 TextContainer

dcase_util.containers.TextContainer文本的容器类，从dcase_util.containers.ListContainer继承。

TextContainer（\ args，\ \ * kwargs）继承自ListContainer的文本的容器类。

调用格式	功能
`TextContainer(\args, \\*kwargs)`	继承自ListContainer的文本的容器类。
`TextContainer.load([filename, headers])`	加载文件
`TextContainer.save([filename])`	保存文件
`TextContainer.show()`	打印容器内容
`TextContainer.log([level])`	日志容器内容

1.2 Data containers

1.2.1 DataContainer

dcase_util.containers.DataContainer，数据的容器类，从dcase_util.containers.ObjectContainer继承。

调用格式	功能
`DataContainer([data, stats, metadata, ...])`	数据的容器类，从ObjectContainer继承
`DataContainer.load([filename])`	Load file
`DataContainer.save([filename])`	Save file
`DataContainer.show()`	打印容器内容
`DataContainer.log([level])`	记录容器内容
`DataContainer.data`	数据矩阵
`DataContainer.shape`	数据矩阵的形状
`DataContainer.length`	数据列的数量
`DataContainer.frames`	数据帧的数量
`DataContainer.push_processing_chain_item(...)`	加工链项目入栈
`DataContainer.focus_start`	聚焦段开始
`DataContainer.focus_stop`	聚焦段结束
`DataContainer.stats`	数据矩阵的基本统计
`DataContainer.reset_focus()`	重置聚焦段（Focus segment）
`DataContainer.get_focused()`	从数据数组获取聚焦段
`DataContainer.freeze()`	冻结聚焦段（Freeze focus segment），并复制为容器数据。
`DataContainer.get_frames([frame_ids, frame_hop])`	从数据数组中获取帧。
`DataContainer.plot()`	可视化数据数组。

1.2.2 DataArrayContainer

`dcase_util.containers.DataArrayContainer`

Container class for data, inherited from dcase_util.containers.DataContainer.

调用格式	功能
`DataArrayContainer([data, stats, metadata, ...])`	Array data container `DataArrayContainer.load([filename])`	Load file
`DataArrayContainer.save([filename])`	Save file
`DataArrayContainer.show(`	Print container content
`DataArrayContainer.log([level])`	Log container content
`DataArrayContainer.data`	Data matrix
`DataArrayContainer.shape`	Shape of data matrix
`DataArrayContainer.length`	Number of data columns
`DataArrayContainer.frames`	Number of data frames
`DataArrayContainer.push_processing_chain_item(...)`	Push processing chain item
`ataArrayContainer.focus_start`	Focus segment start
`ataArrayContainer.focus_stop`	Focus segment stop
`DataArrayContainer.stats`	Basic statistics of data matrix.
`DataArrayContainer.reset_focus()`	Reset focus segment
`DataArrayContainer.get_focused()`	Get focus segment from data array.
`DataArrayContainer.freeze()`	Freeze focus segment, copy segment to be container’s data.
`DataArrayContainer.get_frames([frame_ids, ...])`	Get frames from data array.
`DataArrayContainer.plot()`	Visualize data array.

1.2.3 DataMatrix2DContainer

`dcase_util.containers.DataMatrix2DContainer`

DataMatrix2DContainer是二维数据矩阵（numpy.ndarray）的数据容器。

基本用法：

# 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

该容器具有聚焦机制，可灵活定位数据矩阵的一部分。可以根据时间进行对焦（如果时间分辨率已定义，则以秒为单位），或基于帧ID。

使用焦点机制（ focus mechanism），访问数据和可视化数据的示例：

# 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()

调用格式	功能
`DataMatrix2DContainer([data, stats, ...])`	Two-dimensional data matrix container class, inherited from DataContainer.
`DataMatrix2DContainer.load([filename])`	Load file
`DataMatrix2DContainer.save([filename])`	Save file
`DataMatrix2DContainer.show()`	Print container content
`DataMatrix2DContainer.log([level])`	Log container content
`DataMatrix2DContainer.data`	Data matrix
`DataMatrix2DContainer.shape`	Shape of data matrix
`DataMatrix2DContainer.length`	Number of data columns
`DataMatrix2DContainer.frames`	Number of data frames
`DataMatrix2DContainer.vector_length`	Data vector length
`DataMatrix2DContainer.push_processing_chain_item(...)`	Push processing chain item
`DataMatrix2DContainer.focus_start`	Focus segment start
`DataMatri`