dcase_util教程（二）——各单元介绍
生活随笔
收集整理的這篇文章主要介紹了
dcase_util教程（二）——各单元介绍
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
接著上一篇教程，繼續的有各個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繼承類：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | 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）。 |
用法示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | 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[, ...]) | 從字段獲取所有數據 |
用法示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | 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）的數據容器。
基本用法：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | # 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），訪問數據和可視化數據的示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | # 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 |
| DataMatrix2DContainer.focus_stop | Focus segment stop |
| DataMatrix2DContainer.T | Transposed data in a data container |
| DataMatrix2DContainer.stats | Basic statistics of data matrix. |
| DataMatrix2DContainer.reset_focus() | Reset focus segment |
| DataMatrix2DContainer.get_focused() | Get focus segment from data matrix. |
| DataMatrix2DContainer.freeze() | Freeze focus segment, copy segment to be container’s data. |
| DataMatrix2DContainer.get_frames([...]) | Get frames from data matrix. |
| DataMatrix2DContainer.plot() | Visualize data matrix. |
1.2.4 DataMatrix3DContainer
`dcase_util.containers.DataMatrix3DContainer`| DataMatrix3DContainer([data, stats, ...]) | 三位數據矩陣容器, 從DataMatrix2DContainer繼承. |
| DataMatrix3DContainer.load([filename]) | Load file |
| DataMatrix3DContainer.save([filename]) | Save file |
| DataMatrix3DContainer.show() | Print container content |
| DataMatrix3DContainer.log([level])` | Log container content |
| DataMatrix3DContainer.data | Data matrix |
| DataMatrix3DContainer.length | Number of data columns |
| DataMatrix3DContainer.frames | Number of data frames |
1.2.5 BinaryMatrix3DContainer
`dcase_util.containers.BinaryMatrix2DContainer`| BinaryMatrix2DContainer([data, ...]) | Two-dimensional data matrix container class, inherited from DataContainer. |
| BinaryMatrix2DContainer.load([filename]) | Load file |
| BinaryMatrix2DContainer.save([filename]) | Save file |
| BinaryMatrix2DContainer.show() | Print container content |
| BinaryMatrix2DContainer.log([level]) | Log container content |
| BinaryMatrix2DContainer.data | Data matrix |
| BinaryMatrix2DContainer.length | Number of data columns |
| BinaryMatrix2DContainer.frames | Number of data frames |
| BinaryMatrix2DContainer.pad(length[, ...]) | Pad binary matrix along time axis |
| BinaryMatrix2DContainer.plot([...]) | Visualize binary matrix, and optionally synced data matrix. |
1.2.4 DataRepository
dcase_util.containers.DataRepositoryDataRepository是可用于存儲多個其他數據容器的容器。存儲庫存儲具有兩個級別信息的數據：標簽和流。 標簽是更高級別的密鑰，流是第二級。 例如，可以使用儲存庫來儲存與相同音頻信號有關的多個不同聲學特征。 流ID可用于存儲從不同音頻通道提取的特征。 后面的功能可以使用提取器標簽和流ID進行訪問。
用法示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | # 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} |
| DataRepository([data, filename_dict, ...]) | 數據存儲庫容器類將多個DataContainer一起存儲 |
| DataRepository.load([filename_dict]) | Load file list |
| DataRepository.get_container(label[, stream_id]) | Get container from repository |
| DataRepository.set_container(container, label) | Store container to repository |
| DataRepository.push_processing_chain_item(...) | Push processing chain item |
| DataRepository.plot() | 可視化存儲在存儲庫中的數據。 |
1.3 Audio containers
dcase_util.containers.AudioContainerAudioContainer是用于多聲道音頻的數據容器。 它讀取多種格式（WAV，FLAC，M4A，WEBM）并寫入WAV和FLAC文件。 直接從Youtube下載音頻內容也受支持。
基本用法示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | # 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 ) |
該容器具有聚焦機制，可靈活捕捉部分音頻數據，同時保持完整的音頻信號不變。 可以根據時間進行聚焦（如果時間分辨率已定義，則以秒為單位），或基于樣本ID。 可以對單聲道或混音（單聲道）頻道進行聚焦。 音頻容器內容可以通過凍結來替代焦點細分。
使用焦點細分機制的示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | # 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) |
Processing examples:
| 1 2 3 4 5 | # Normalizing audio audio_container.normalize() # Resampling audio to target sampling rate audio_container.resample(target_fs=16000) |
Visualizations examples:
| 1 2 3 4 5 | # Plotting waveform audio_container.plot_wave() # Plotting spectrogram audio_container.plot_spec() |
| AudioContainer([data, fs, ...]) | Audio container class. |
| AudioContainer.load([filename, fs, mono, ...]) | Load file |
| AudioContainer.load_from_youtube(query_id[, ...]) | Load audio data from youtube |
| AudioContainer.save([filename, bit_depth])` | Save audio |
| AudioContainer.show() | Print container content |
| AudioContainer.log([level]) | Log container content |
| AudioContainer.data | Audio data |
| AudioContainer.focus_start_samples | Focus segment start in samples. |
| AudioContainer.focus_start_seconds | Focus segment start in seconds. |
| AudioContainer.focus_stop_samples | Focus segment stop in samples. |
| AudioContainer.focus_stop_seconds | Focus segment stop in seconds. |
| AudioContainer.focus_channel | Focus channel |
| AudioContainer.loaded | Audio load status. |
| AudioContainer.shape | Audio data shape. |
| AudioContainer.length | Length of audio data in samples. |
| AudioContainer.duration_samples | Duration of audio data in samples. |
| AudioContainer.duration_ms | Duration of audio data in milliseconds. |
| AudioContainer.duration_sec | Duration of audio data in seconds. |
| AudioContainer.streams | Rename channels for compatibility. |
| AudioContainer.empt | Check if audio data is empty. |
| AudioContainer.reset_focus() | Reset focus segment. |
| AudioContainer.set_focus([start, stop, ...]) | Set focus segment |
| AudioContainer.get_focused() | Get focus segment from audio data. |
| AudioContainer.freeze() | Freeze focus segment, copy segment to be container’s data. |
| AudioContainer.frames([frame_length, ...]) | Slice audio into overlapping frames. |
| AudioContainer.normalize([headroom]) | Normalize audio data. |
| AudioContainer.resample(target_fs[, scale, ...]) | Resample audio data. |
| AudioContainer.mixdown() | Mix all audio channels into single channel. |
| AudioContainer.plot([plot_type]) | Visualize audio data |
| AudioContainer.plot_wave([x_axis, ...]) | Visualize audio data as waveform. |
| AudioContainer.plot_spec([spec_type, ...]) | Visualize audio data as spectrogram. |
1.4 Feature containers
FeatureContainer
dcase_util.containers.FeatureContainer
| FeatureContainer([data, stats, metadata, ...]) | 從DataContainer繼承的單個特征矩陣的特征容器類。 |
FeatureRepository
dcase_util.containers.FeatureRepository
| FeatureRepository([filename_dict, ...]) | Feature repository container class to store multiple FeatureContainers together. |
1.5 Mapping containers
OneToOneMappingContainer，dcase_util.containers.OneToOneMappingContainer
| OneToOneMappingContainer(\*args, \*\*kwargs) | Mapping container class for 1:1 data mapping, inherited from DictContainer class. |
| OneToOneMappingContainer.load([filename]) | Load file |
| OneToOneMappingContainer.save([filename]) | Save file |
| OneToOneMappingContainer.show() | Print container content |
| OneToOneMappingContainer.log([level]) | Log container content |
| OneToOneMappingContainer.map(key[, default]) | Map with a key. |
| OneToOneMappingContainer.flipped | Exchange map key and value pairs. |
1.6 Metadata containers
MetaDataItem
dcase_util.containers.MetaDataItem
| MetaDataItem(\*args, \*\*kwargs) | Meta data item class, inherited from standard dict class. |
| MetaDataItem.show() | Print container content |
| MetaDataItem.log([level]) | Log container content |
| MetaDataItem.id | Unique item identifier |
| MetaDataItem.get_list() | Return item values in a list with specified order. |
| MetaDataItem.filename | Filename |
| MetaDataItem.filename_original | Filename |
| MetaDataItem.scene_label | Scene label |
| MetaDataItem.event_label | Event label |
| MetaDataItem.onset | Onset |
| MetaDataItem.offset | Offset |
| MetaDataItem.identifier | Identifier |
| MetaDataItem.source_label | Source label |
| MetaDataItem.tags | Tags |
| MetaDataItem.active_within_segment(start, stop) | Item active withing given segment. |
MetaDataContainer
dcase_util.containers.MetaDataContainer
| MetaDataContainer(\*args, \*\*kwargs) | Meta data container class, inherited from ListDictContainer. |
| MetaDataContainer.log([level, show_data, ...]) | Log container content |
| MetaDataContainer.log_all([level]) | Log container content with all meta data items. |
| MetaDataContainer.show([show_data, show_stats]) | Print container content |
| MetaDataContainer.show_all() | Print container content with all meta data items. |
| MetaDataContainer.load([filename, fields, ...]) | Load event list from delimited text file (csv-formatted) |
| MetaDataContainer.save([filename, fields, ...]) | Save content to csv file |
| MetaDataContainer.append(item) | Append item to the meta data list |
| MetaDataContainer.file_count | Number of files |
| MetaDataContainer.event_count | Number of events |
| MetaDataContainer.scene_label_count | Number of unique scene labels |
| MetaDataContainer.event_label_count | Number of unique event labels |
| MetaDataContainer.identifier_count | Number of unique identifiers |
| MetaDataContainer.tag_count | Number of unique tags |
| MetaDataContainer.unique_files | Unique files |
| MetaDataContainer.unique_event_labels | Unique event labels |
| MetaDataContainer.unique_scene_labels | Unique scene labels |
| MetaDataContainer.unique_tags | Unique tags |
| MetaDataContainer.unique_identifiers | Unique identifiers |
| MetaDataContainer.max_offset | Find the offset (end-time) of last event |
| MetaDataContainer.get_string([show_data, ...]) | Get content in string format |
| MetaDataContainer.filter([filename, ...]) | Filter content |
| MetaDataContainer.filter_time_segment([...]) | Filter time segment |
| MetaDataContainer.process_events([...]) | Process event content |
| MetaDataContainer.add_time(time) | Add time offset to event onset and offset timestamps |
| MetaDataContainer.stats([event_label_list, ...]) | Statistics of the container content |
| MetaDataContainer.scene_stat_counts() | Scene count statistics |
| MetaDataContainer.event_stat_counts() | Event count statistics |
| MetaDataContainer.tag_stat_counts() | Tag count statistics |
| MetaDataContainer.to_event_roll([...]) | Event roll |
| MetaDataContainer.intersection(second_metadata) | Intersection of two meta containers |
| MetaDataContainer.intersection_report(...) | Intersection report for two meta containers |
| MetaDataContainer.difference(second_metadata) | Difference of two meta containers |
1.7 Parameter containers
ParameterContainer
dcase_util.containers.ParameterContainer
| ParameterContainer(\*args, \*\*kwargs) | 參數容器類，用于繼承自DictContainer類的參數。 |
AppParameterContainer
dcase_util.containers.AppParameterContainer
| AppParameterContainer([data, app_base, ...]) | 應用程序參數的參數容器類，繼承自ParameterContainer。 |
| AppParameterContainer.reset([field_labels, ...]) | |
| AppParameterContainer.process([...]) | Process parameters |
| AppParameterContainer.override(override) | 遞歸地覆蓋容器內容。 |
| AppParameterContainer.get_path_translated(path) | 用路徑獲取數據，路徑可以包含將被翻譯的字符串常量。 |
| AppParameterContainer.set_path_translated(...) | 用路徑設置數據，路徑可以包含將被翻譯的字符串常量。 |
DCASEAppParameterContainer
dcase_util.containers.DCASEAppParameterContainer
| DCASEAppParameterContainer(\*args, \*\*kwargs) | DCASE應用程序參數文件的參數容器類，從AppParameterContainer繼承。 |
ParameterListContainer
dcase_util.containers.ParameterListContainer
| ParameterListContainer(\*args, \*\*kwargs) | 參數列表容器，繼承自ListDictContainer。 |
1.8 Probability containers
ProbabilityItem
dcase_util.containers.ProbabilityItem
| ProbabilityItem(\*args, \*\*kwargs) | 概率數據項類，繼承自標準字典類。 |
| ProbabilityItem.show() | Print container content |
| ProbabilityItem.log([level]) | Log container content |
| ProbabilityItem.filename | Filename |
| ProbabilityItem.label | Label |
| ProbabilityItem.probability | Returns: |
| ProbabilityItem.id | 唯一的項目（item）標識 |
| ProbabilityItem.get_list() | 以指定順序返回列表中的項目（item）值。 |
ProbabilityContainer
dcase_util.containers.ProbabilityContainer
| ProbabilityContainer(\*args, \*\*kwargs) | 概率數據容器類，繼承自ListDictContainer。 |
| ProbabilityContainer.show() | Print container content |
| ProbabilityContainer.log([level]) | Log container content |
| ProbabilityContainer.load([filename]) | 來自分隔文本文件的加載概率列表（csv格式） |
| ProbabilityContainer.save([filename, delimiter]) | Save content to csv file |
| ProbabilityContainer.append(item) | Append item to the meta data list |
| ProbabilityContainer.unique_files | Unique files |
| ProbabilityContainer.unique_labels | Unique labels |
| ProbabilityContainer.filter([filename, ...]) | Filter content |
1.9 MIxins
ContainerMixin
dcase_util.containers.ContainerMixin
| ContainerMixin(\*args, \*\*kwargs) | Container mixin to give class basic container methods. |
| ContainerMixin.show() | Print container content |
| ContainerMixin.log([level]) | Log container content |
FileMixin
dcase_util.containers.FileMixin
| FileMixin(\*args, \*\*kwargs) | File mixin to give class methods to load and store content. |
| FileMixin.get_file_information() | Get file information, filename |
| FileMixin.detect_file_format([filename]) | Detect file format from extension |
| FileMixin.validate_format() | Validate file format |
| FileMixin.exists() | Checks that file exists |
| FileMixin.empty() | Check if file is empty |
| FileMixin.delimiter([exclude_delimiters]) | Use csv.sniffer to guess delimiter for CSV file |
| FileMixin.is_package([filename]) | Determine if the file is compressed package. |
PackageMixin
dcase_util.containers.PackageMixin
| PackageMixin(\*args, \*\*kwargs) | 打包mixin以提供處理壓縮文件包的類基本方法。 |
| PackageMixin.package_password | Package password |
| PackageMixin.extract([overwrite, ...]) | 解壓縮包 |
2. Data
數據處理的類
2.1 Buffers
dcase_util.data.DataBuffer
數據緩沖類，可用于存儲與項目關聯的數據和元數據。 項目數據通過項目鍵進行訪問。當內部緩沖區被填滿時，最舊的項目被替換。
| DataBuffer([size]) | 數據緩沖區（先進先出） |
| DataBuffer.set(key[, data, meta]) | 將項目（item）插入緩沖區 |
| DataBuffer.get(key) | 根據鍵獲取項目（item） |
| DataBuffer.clear() | 清空緩沖區 |
| DataBuffer.count | 緩沖區使用情況 |
| DataBuffer.full | 緩沖區已滿 |
| DataBuffer.key_exists(key) | 檢查鍵（key）是否存在于緩沖區中 |
2.2 Encoders
BinaryMatrixEncoder
dcase_util.data.BinaryMatrixEncoder
| BinaryMatrixEncoder([label_list，...]) | 二進制矩陣編碼器基類 |
| BinaryMatrixEncoder.pad(length [，binary_matrix]) | 沿時間軸填充二進制矩陣 |
| BinaryMatrixEncoder.plot([binary_matrix，...]) | 可視化二進制矩陣和可選的同步數據矩陣。 |
OneHotEncoder
dcase_util.data.OneHotEncoder
| OneHotEncoder([label_list, time_resolution, ...]) | One hot encoder class |
| OneHotEncoder.encode(label[, length_frames, ...]) | Generate one hot binary matrix |
ManyHotEncoder
dcase_util.data.ManyHotEncoder
| ManyHotEncoder([label_list, ...]) | Many hot encoder class |
| ManyHotEncoder.encode(label_list[, ...]) | Generate one hot binary matrix |
EventRollEncoder
dcase_util.data.EventRollEncoder
| EventRollEncoder([label_list, ...]) | Event list encoder class |
| EventRollEncoder.encode(metadata_container) | Generate event roll from MetaDataContainer |
2.3 Data manipulators
Normalizer
dcase_util.data.Normalizer
| Normalizer([n, s1, s2, mean, std]) | 數據歸一化器來累積數據統計 |
| Normalizer.log([level]) | 記錄容器內容 |
| Normalizer.show() | 打印容器內容 |
| Normalizer.load([filename]) | Load file |
| Normalizer.save([filename]) | Save file |
| Normalizer.mean | Mean vector |
| Normalizer.std | 標準差矢量 |
| Normalizer.reset() | 充值內部變量 |
| Normalizer.accumulate(data[, time_axis]) | 計算統計量 |
| Normalizer.finalize() | 完成統計計算 |
| Normalizer.normalize(data) | 使用該類的內部統計量標準化特征矩陣 |
RepositoryNormalizer
dcase_util.data.RepositoryNormalizer
| RepositoryNormalizer([normalizer_dict, ...]) | Data repository normalizer |
| RepositoryNormalizer.load(filename_dict) | Load normalizers from disk. |
| RepositoryNormalizer.normalize(data_repository) | Normalize data repository |
- Aggregator（聚合）
dcase_util.data.Aggregator
數據聚合器可用于處理窗口中的數據矩陣。 這個處理階段可以用來通過計算它們的平均值和標準差來在特定的窗口長度內折疊數據，或者將該矩陣平坦化為單個向量。
支持的處理方法：
| 1 2 3 4 5 6 7 8 9 10 | 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) |
| Aggregator([win_length_frames, ...]) | Data aggregator |
| Aggregator.log([level]) | Log container content |
| Aggregator.show() | Print container content |
| Aggregator.load([filename]) | Load file |
| Aggregator.save([filename]) | Save file |
| Aggregator.aggregate([data]) | Aggregate data |
Sequencer
dcase_util.data.Sequencer
Sequencer類將數據矩陣處理成序列（圖像）。 序列可以重疊，并且可以在調用之間改變排序網格（移位）。
類名 | 功能
—|—
Sequencer([frames, hop_length_frames, ...]) | Data sequencer
Sequencer.log([level]) | Log container content
Sequencer.show() | Print container content
Sequencer.load([filename]) | Load file
Sequencer.save([filename]) | Save file
Sequencer.sequence([data]) | Make sequences
Sequencer.increase_shifting([shift_step]) | Increase temporal shifting
Stacker
dcase_util.data.Stacker
數據堆疊類。 Class使用矢量配方和DataRepository，并創建適當的數據矩陣。
矢量方法（Vector recipe）
使用recipe，您可以選擇全矩陣，只選擇開始和結束索引的一部分，或從中選擇單個行。
例子：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | [ { '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] } } ] |
請參閱dcase_util.utils.VectorRecipeParser如何方便地使用配方字符串來生成上述數據結構。
| Stacker([recipe, hop]) | Data stacker |
| Stacker.log([level]) | Log container content |
| Stacker.show() | Print container content |
| Stacker.load([filename]) | Load file |
| Stacker.save([filename]) | Save file |
| Stacker.stack(repository) | Vector creation based on recipe |
Selector
dcase_util.data.Selector，數據選擇類
| Selector(\*\*kwargs) | Data selector |
| Selector.log([level]) | Log container content |
| Selector.show() | Print container content |
| Selector.load([filename]) | Load file |
| Selector.save([filename]) | Save file |
| Selector.select(data[, selection_events]) | Selecting feature repository with given events |
Masker
dcase_util.data.Masker，數據屏蔽（篩選）類。
| Masker(\*\*kwargs) | Data masker |
| Masker.log([level]) | Log container content |
| Masker.show() | Print container content |
| Masker.load([filename]) | Load file |
| Masker.save([filename]) | Save file |
| Masker.mask(data[, mask_events]) | Masking feature repository with given events |
2.4 Probability
ProbabilityEncoder，dcase_util.data.ProbabilityEncoder
| ProbabilityEncoder([label_list]) | Constructor |
| ProbabilityEncoder.log([level]) | Log container content |
| ProbabilityEncoder.show() | Print container content |
| ProbabilityEncoder.load([filename]) | Load file |
| ProbabilityEncoder.save([filename]) | Save file |
| ProbabilityEncoder.collapse_probabilities(...) | Collapse probabilities |
| ProbabilityEncoder.collapse_probabilities_windowed(...) | Collapse probabilities in windows |
| ProbabilityEncoder.binarization(probabilities) | Binarization |
2.5 Eecisions
DecisionEncoder，dcase_util.data.DecisionEncoder
| DecisionEncoder([label_list]) | 構造器 |
| DecisionEncoder.log([level]) | Log container content |
| DecisionEncoder.show() | Print container content |
| DecisionEncoder.load([filename]) | Load file |
| DecisionEncoder.save([filename]) | Save file |
| DecisionEncoder.majority_vote(frame_decisions) | 多票制 |
| DecisionEncoder.find_contiguous_regions(...) | 從具有布爾值的numpy.array找到連續區域。 |
| DecisionEncoder.process_activity(...[, operator]) | 處理動態數組（二進制） |
3. Datasets
3.1 Dataset
dcase_util.datasets.Dataset這是基類，所有專用數據集都是從它繼承而來的?；惐旧聿荒苁褂?。
用法示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 | # 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]) |
| Dataset([name, storage_name, data_path, ...]) | 數據集基類 |
| Dataset.initialize() | 數據集基類 |
| Dataset.download_packages() | 通過互聯網將數據集包下載到本地路徑 |
| Dataset.extract_packages() | 提取數據集包 |
| Dataset.prepare() | 為使用準備數據集 |
| Dataset.process_meta_item(item[, absolute_path]) | 處理單個元數據項目 |
| Dataset.check_filelist() | 從文件列表生成哈希，并檢查它是否與保存在filelist.hash中的哈希匹配 |
| Dataset.show() | 打印數據集信息 |
| Dataset.log() | 記錄數據集信息 |
| Dataset.load() | 將數據集元數據和交叉驗證集加載到容器中 |
| Dataset.load_meta() | 將元數據添加到容器中 |
| Dataset.load_crossvalidation_data() | 將交叉驗證加載到容器中 |
| Dataset.audio_files | 獲取數據集中的所有音頻文件 |
| Dataset.audio_file_count | 獲取數據集中音頻文件的數量 |
| Dataset.meta | 獲取數據集的元數據。 |
| Dataset.meta_count | 元數據項的數量 |
| Dataset.error_meta | 獲取數據集的音頻錯誤元數據 |
| Dataset.error_meta_count | 錯誤元數據項的數量 |
| Dataset.folds([mode]) | fold ID列表 |
| Dataset.fold_count | 評估設置中的fold次數 |
| Dataset.evaluation_setup_filename([...]) | 評估設置文件名生成 |
| Dataset.train([fold, absolute_paths]) | 訓練列表 |
| Dataset.test([fold, absolute_paths]) | 測試列表 |
| Dataset.eval([fold, absolute_paths]) | 評估列表 |
| Dataset.train_files([fold, absolute_paths]) | 訓練文件列表 |
| Dataset.test_files([fold, absolute_paths]) | 測試文件列表 |
| Dataset.eval_files([fold, absolute_paths]) | 評估文件列表 |
| Dataset.validation_split([fold, split_type, ...]) | 驗證文件列表 |
| Dataset.validation_files_dataset([fold, verbose]) | 由數據集提供的驗證文件列表 |
| Dataset.validation_files_random([fold, ...]) | 從訓練集中隨機選擇的驗證文件列表。 |
| Dataset.validation_files_balanced([fold, ...]) | 在保持數據平衡的同時隨機選擇驗證文件列表 |
| Dataset.scene_labels() | 元數據中唯一場景標簽的列表 |
| Dataset.scene_label_count() | 元數據中唯一場景標簽的數量 |
| Dataset.event_labels(\*\*kwargs) | 元數據中的唯一事件標簽列表 |
| Dataset.event_label_count(\*\*kwargs) | 元數據中的唯一事件標簽列表 |
| Dataset.tags() | 元數據中唯一音頻標簽的列表 |
| Dataset.tag_count() | 元數據中唯一音頻標簽的數量 |
| Dataset.file_meta(filename) | 給定文件的元數據 |
| Dataset.file_error_meta(filename) | 給定文件的錯誤元數據 |
| Dataset.file_features(filename) | 預先計算給定文件的聲學特征 |
| Dataset.relative_to_absolute_path(path) | 將相對路徑轉換為絕對路徑 |
| Dataset.absolute_to_relative_path(path) | 將絕對路徑轉換為相對路徑 |
| Dataset.dataset_bytes() | 數據集的總下載大小（以字節為單位） |
| Dataset.dataset_size_string() | 字符串中數據集的總下載大小 |
| Dataset.dataset_size_on_disk() | 當前存儲在本地的數據集的總大小 |
3.2 AcousticScenesDataset
dcase_util.datasets.AcousticSceneDataset，格式如下：
AcousticSceneDataset(\*args, \*\*kwargs)
繼承自AcousticSceneDataset的幾個類：
| TUTAcousticScenes_2017_DevelopmentSet([...]) | TUT Acoustic scenes 2017 開發數據集 |
| TUTAcousticScenes_2017_EvaluationSet([...]) | TUT Acoustic scenes 2017 評估數據集 |
| TUTAcousticScenes_2016_DevelopmentSet([...]) | TUT Acoustic scenes 2016 開發數據集 |
| TUTAcousticScenes_2016_EvaluationSet([...]) | TUT Acoustic scenes 2016 評估數據集 |
3.3 SoundEventDataset
dcase_util.datasets.SoundEventDataset
| SoundEventDataset(\*args, \*\*kwargs) | |
| SoundEventDataset.event_label_count([...]) | Number of unique scene labels in the meta data. |
| SoundEventDataset.event_labels([scene_label]) | List of unique event labels in the meta data. |
| SoundEventDataset.train([fold, ...]) | List of training items. |
| SoundEventDataset.test([fold, ...]) | List of testing items. |
繼承自SoundEventDataset的幾個類：
| TUTRareSoundEvents_2017_DevelopmentSet([...]) | TUT Acoustic scenes 2017 development dataset |
| TUTRareSoundEvents_2017_EvaluationSet([...]) | TUT Acoustic scenes 2017 evaluation dataset |
| TUTSoundEvents_2017_DevelopmentSet([...]) | TUT Sound events 2017 development dataset |
| TUTSoundEvents_2017_EvaluationSet([...]) | TUT Sound events 2017 evaluation dataset |
| TUTSoundEvents_2016_DevelopmentSet([...]) | TUT Sound events 2016 development dataset |
| TUTSoundEvents_2016_EvaluationSet([...]) | TUT Sound events 2016 evaluation dataset |
| TUT_SED_Synthetic_2016([storage_name, ...]) | TUT SED Synthetic 2016 |
3.4 AudioTaggingDataset
dcase_util.datasets.AudioTaggingDataset
語法格式：AudioTaggingDataset(\*args, \*\*kwargs)
| DCASE2017_Task4tagging_DevelopmentSet([...]) | DCASE 2017 Large-scale weakly supervised sound event detection for smart cars |
| DCASE2017_Task4tagging_EvaluationSet([...]) | DCASE 2017 Large-scale weakly supervised sound event detection for smart cars |
| CHiMEHome_DomesticAudioTag_DevelopmentSet([...]) | Constructor |
4. Decorators（修飾符）
用于修飾函數的輔助類
RunOnce
dcase_util.decorators.RunOnce
RunOnce(f) Decorator 類只允許執行一次
5. Features
提取特征的類
- FeatureExtractor（基本特征提取）
dcase_util.features.FeatureExtractor，特征提取基本類，語法格式：FeatureExtractor([fs, win_length_samples, ...])
| 1 | 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) |
- SpectralFeatureExtractor
dcase_util.features.SpectralFeatureExtractor
| SpectralFeatureExtractor([spectrogram_type, ...]) | 特殊特征提取基礎類 |
| SpectralFeatureExtractor.get_window_function(n) | 窗函數 |
| SpectralFeatureExtractor.get_spectrogram(y) | 譜圖 |
- MelExtractor（Mel）
dcase_util.features.MelExtractor
| MelExtractor([fs, win_length_samples, ...]) | 梅爾帶能量特征提取類 |
| MelExtractor.extract(y) | 提取音頻信號的特征 |
- MfccStaticExtractor（MFCC）
dcase_util.features.MfccStaticExtractor
| MfccStaticExtractor([fs, ...]) | 用于提取靜態MFCC功能的特征提取器類 |
| MfccStaticExtractor.extract(y) | 提取音頻信號的特征 |
- MfccDeltaExtractor（MFCC一階導）
dcase_util.features.MfccDeltaExtractor
| MfccDeltaExtractor([fs, win_length_samples, ...]) | MFCC一階導 |
| MfccDeltaExtractor.extract(y) | 提取音頻信號的特征 |
- MfccAccelerationExtractor（MFCC二階導）
dcase_util.features.MfccAccelerationExtractor
| MfccAccelerationExtractor([fs, ...]) | （MFCC二階導 MFCC acceleration features |
| MfccAccelerationExtractor.extract(y) | 提取音頻信號的特征 |
- ZeroCrossingRateExtractor（過零率）
dcase_util.features.ZeroCrossingRateExtractor
| ZeroCrossingRateExtractor([fs, ...]) | 過零率 |
| ZeroCrossingRateExtractor.extract(y) | 提取音頻信號的特征 |
- RMSEnergyExtractor（均方根能量特征）
dcase_util.features.RMSEnergyExtractor
| RMSEnergyExtractor([fs, win_length_samples, ...]) | 均方根能量特征 |
| RMSEnergyExtractor.extract(y) | 提取音頻信號的特征 |
- SpectralCentroidExtractor（光譜質心）
dcase_util.features.SpectralCentroidExtractor
| SpectralCentroidExtractor([fs, ...]) | 光譜質心 |
| SpectralCentroidExtractor.extract(y) | 提取音頻信號的特征 |
6. Files
6.1 File
dcase_util.files.File，通用的文件類：
| File(\*args, \*\*kwargs) | 通用類 |
| File.load([filename]) | 加載文件 |
| File.save(data[, filename]) | 保存文件 |
| File.get_file_information() | 得到文件信息、文件名 |
| File.detect_file_format([filename]) | 根據擴展檢測文件格式 |
| File.validate_format() | 驗證文件格式有效性 |
| File.exists() | 檢查文件是否存在 |
| File.empty() | 檢查文件是否為空 |
| File.delimiter([exclude_delimiters]) | 使用csv.sniffer猜測CSV文件的分隔符 |
| File.is_package([filename]) | 確定文件是否為壓縮包 |
6.2 FileLock
dcase_util.files.FileLock，簡單的基于文件的鎖定類。
| FileLock(filename[, timeout, ...]) | 簡單的基于文件的鎖定類 |
| FileLock.lock() | 鎖定文件 |
| FileLock.release() | 釋放文件鎖 |
| FileLock.expired | 檢查比指定超時更早的鎖定文件 |
| FileLock.is_locked | 檢查鎖定文件是否存在 |
| FileLock.touch() | 使用當前時間戳創建鎖定文件 |
6.3 remotefile
dcase_util.files.RemoteFile遠程文件處理類。
| RemoteFile([filename，content_type，...]) | 遠程文件類 |
| RemoteFile.download() | 下載遠程文件并將其保存為本地文件。 |
| RemoteFile.is_content_type(content_type) | 檢查該文件是否包含給定類型的內容 |
| RemoteFile.local_md5 | 本地文件的校驗和。 |
| RemoteFile.local_modified | 修改本地文件的時間戳。 |
| RemoteFile.local_bytes | 本地文件的文件大小(以字節為單位)。 |
| RemoteFile.local_size_string() | 以可讀形式存在的本地文件的文件大小。 |
| RemoteFile.local_exists() | 檢查本地文件是否存在。 |
| RemoteFile.local_changed() | 檢查本地文件是否對應于遠程文件(基于校驗和或修改時間和文件大小)。 |
| RemoteFile.remote_file | 指向遠程文件的URL |
| RemoteFile.remote_modified | 遠程文件的最后修改時間。 |
| RemoteFile.remote_bytes | 遠程文件的文件大小。 |
| RemoteFile.remote_status | 遠程文件的狀態。 |
| RemoteFile.remote_size_string() | 以人類可讀形式的遠程文件的文件大小。 |
| RemoteFile.remote_info() | 獲取有關刪除文件(狀態，大小，校驗和，上次修改時間)的信息。 |
| RemoteFile.remote_exists() | 檢查遠程文件是否存在(基于HTTP狀態碼)。 |
6.4 RemotePackage
dcase_util.files.RemotePackage，遠程包處理類。
| RemotePackage([filename，content_type，...]) | 遠程軟件包類 |
| RemotePackage.download() | 下載遠程文件并將其保存為本地文件。 |
| RemotePackage.extract([覆蓋，...]) | 解壓縮包 |
| RemotePackage.package_password | 包密碼 |
| RemotePackage.is_content_type(content_type) | 檢查該文件是否包含給定類型的內容 |
| RemotePackage.local_md5 | 本地文件的校驗和。 |
| RemotePackage.local_modified | 修改本地文件的時間戳。 |
| RemotePackage.local_bytes | 本地文件的文件大小(以字節為單位)。 |
| RemotePackage.local_size_string() | 以可讀形式存儲本地文件的文件大小。 |
| RemotePackage.local_exists() | 檢查本地文件是否存在。 |
| RemotePackage.local_changed() | 檢查本地文件是否對應于遠程文件(基于校驗和或修改時間和文件大小)。 |
| RemotePackage.remote_file | 指向遠程文件的URL |
| RemotePackage.remote_modified | 遠程文件的最后修改時間。 |
| RemotePackage.remote_bytes | 遠程文件的文件大小。 |
| RemotePackage.remote_status | 遠程文件的狀態。 |
| RemotePackage.remote_size_string() | 以可讀形式顯示遠程文件的文件大小。 |
| RemotePackage.remote_info() | 獲取有關刪除文件(狀態，大小，校驗和，上次修改時間)的信息。 |
| RemotePackage.remote_exists() | 檢查遠程文件是否存在(基于HTTP狀態碼)。 |
6.5 Serializer
dcase_utils.files.Serializer，數據序列化類
| Serializer | 數據序列化類 |
| Serializer.load_yaml(filename) | 加載YAML文件 |
| Serializer.load_cpickle(filename) | 加載CPICKLE文件 |
| Serializer.load_json(filename) | 加載JSON文件 |
| Serializer.load_msgpack(filename) | Load MSGPACK file |
| Serializer.load_marshal(filename) | Load MARSHAL file |
| Serializer.save_yaml(filename, data) | Save data into YAML file |
| Serializer.save_cpickle(filename, data) | Save data into CPICKLE file |
| Serializer.save_json(filename, data) | Save data into JSON file |
| Serializer.save_msgpack(filename, data) | Save data into MSGPACK file |
| Serializer.save_marshal(filename, data) | Save data into MARSHAL file |
7. Keras utilities
使用Keras深度學習庫的單元。
7.1 Model
dcase_util.keras.model。*
| create_sequential_model(model_parameter_list) | 創建順序Keras模型 |
| model_summary_string(keras_model) | 字符串中的模型摘要，類似于Keras模型摘要函數。 |
7.2 Callbacks
用法示例如何將外部度量與dcase_util提供的Callback類一起使用：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 | 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 |
ProgressLoggerCallback
dcase_util.keras.ProgressLoggerCallback，Keras回調用于存儲tqdm進度條或日志記錄界面的指標。 實現Keras回調API。此回調與標準的ProgbarLogger Keras回調非常相似，但它增加了對日志接口和外部度量（在Keras訓練過程之外計算的度量）的支持。
| ProgressLoggerCallback([manual_update，...]) | Keras回調在日志界面中顯示指標。 |
- ProgressPlotterCallback
dcase_util.keras.ProgressPlotterCallback,keras回調在培訓過程中計劃進度并將最終進展保存到數字中。 實現Keras回調API。
| ProgressPlotterCallback([epochs，...]) | Keras回調在訓練過程中繪制進度并將最終進度保存到圖中。 |
StopperCallback
dcase_util.keras.StopperCallback，keras回調停止訓練時，改善沒有在規定數量的時代看到。 實現Keras回調API。此回調與標準的EarlyStopping Keras回調非常相似，但它增加了對外部度量標準（在Keras培訓過程之外計算的度量）的支持。
| StopperCallback([epochs，manual_update，...]) | Keras回調在特定時間段內沒有發現改進時停止訓練。 |
- StasherCallback
dcase_util.keras.StasherCallback，keras回調監測訓練過程并存儲最佳模型。實現Keras回調API。
該回調與標準的ModelCheckpoint Keras回調非常相似，但它增加了對外部度量（在Keras培訓過程之外計算的度量）的支持。
| StasherCallback([epochs，manual_update，...]) | Keras回調監視訓練過程并存儲最佳模型。 |
- BaseCallback
dcase_util.keras.BaseCallback
| BaseCallback([epochs, manual_update, ...]) | 回調基礎類 |
7.3 Utils
dcase_util.keras.utils. *
| setup_keras | 僅執行一次的修飾類 |
8. Processors（數據處理器類）
8.1 Processing chain
- ProcessingChainItem
dcase_util.processors.ProcessingChainItem
| ProcessingChainItem(\*args, \*\*kwargs) |
- ProcessingChain
dcase_util.processors.ProcessingChain
| ProcessingChain(\*args, \*\*kwargs) | |
| ProcessingChain.show_chain() | 顯示鏈信息 |
| ProcessingChain.log_chain([level]) | 記錄鏈信息 |
| ProcessingChain.push_processor(processor_name) | 將處理器項目推送到鏈中。 |
| ProcessingChain.process([data]) | 用處理鏈處理數據 |
| ProcessingChain.call_method(method_name[, ...]) | 調用處理鏈項目中的類方法 |
| ProcessingChain.processor_exists(processor_name) | 檢查處理器是否存在于鏈中 |
| ProcessingChain.processor_class_reference(...) | 處理器類的引用 |
| ProcessingChain.processor_class(...) | 初始化處理器類 |
8.2 Audio
- AudioReadingProcessor
dcase_util.processors.AudioReadingProcessor
| AudioReadingProcessor([data, fs, ...]) | 構造函數 |
| AudioReadingProcessor.process([data, ...]) | 音頻讀取 |
- MonoAudioReadingProcessor
dcase_util.processors.MonoAudioReadingProcessor
| MonoAudioReadingProcessor([data, fs, …]) | 構造函數 |
| MonoAudioReadingProcessor.process([data, …]) | 音頻讀取 |
8.3 Data
- AggregationProcessor
dcase_util.processors.AggregationProcessor
| AggregationProcessor([win_length_frames, ...]) | Data aggregation processor |
| AggregationProcessor.process([data]) | Process features |
- SequencingProcessor
dcase_util.processors.SequencingProcessor
| SequencingProcessor([frames, ...]) | Data sequencing processor |
| SequencingProcessor.process([data]) | Process |
- NormalizationProcessor
dcase_util.processors.NormalizationProcessor
| NormalizationProcessor([n, s1, s2, mean, std]) | Data normalizer to accumulate data statistics |
| NormalizationProcessor.process([data]) | Normalize feature matrix with internal statistics of the class |
- RepositoryNormalizationProcessor
dcase_util.processors.RepositoryNormalizationProcessor
| RepositoryNormalizationProcessor([parameters]) | Data normalizer to accumulate data statistics inside repository |
| RepositoryNormalizationProcessor.process([data]) | Normalize data repository with internal statistics |
- StackingProcessor
dcase_util.processors.StackingProcessor
| StackingProcessor([recipe, hop]) | Data stacking processor |
| StackingProcessor.process([data]) | Vector creation based on recipe |
- OneHotEncodingProcessor
dcase_util.processors.OneHotEncodingProcessor
| OneHotEncodingProcessor([label_list, ...]) | Event roll encoding processor |
| OneHotEncodingProcessor.process([data, ...]) | Encode metadata |
- ManyHotEncodingProcessor
dcase_util.processors.ManyHotEncodingProcessor
| ManyHotEncodingProcessor([label_list, ...]) | Event roll encoding processor |
| ManyHotEncodingProcessor.process([data, ...]) | Encode metadata |
- EventRollEncodingProcessor
dcase_util.processors.EventRollEncodingProcessor
| EventRollEncodingProcessor([label_list, ...]) | Event roll encoding processor |
| EventRollEncodingProcessor.process([data]) | Encode metadata |
8.4 Features
- RepositoryFeatureExtractorProcessor
dcase_util.processors.RepositoryFeatureExtractorProcessor
| RepositoryFeatureExtractorProcessor([parameters]) | 構造器 |
| RepositoryFeatureExtractorProcessor.process([data]) | 提取特征 |
- FeatureExtractorProcessor
dcase_util.processors.FeatureExtractorProcessor
| FeatureExtractorProcessor(\*args, \*\*kwargs) | 構造器 |
| FeatureExtractorProcessor.process([data]) | 提取特征 |
- MelExtractorProcessor（Mel能量）
dcase_util.processors.MelExtractorProcessor
| MelExtractorProcessor([fs, ...]) | 構造器 |
| MelExtractorProcessor.process([data]) | 提取特征 |
- MfccStaticExtractorProcessor（MFCC）
dcase_util.processors.MfccStaticExtractorProcessor
| MfccStaticExtractorProcessor([fs, ...]) | 構造器 |
| MfccStaticExtractorProcessor.process([data]) | 提取特征 |
- MfccDeltaExtractorProcessor（MFCC一階導）
dcase_util.processors.MfccDeltaExtractorProcessor
| MfccDeltaExtractorProcessor([fs, ...]) | 構造器 |
| MfccDeltaExtractorProcessor.process([data]) | 提取特征 |
- MfccAccelerationExtractorProcessor（MFCC二階導）
dcase_util.processors.MfccAccelerationExtractorProcessor
| MfccAccelerationExtractorProcessor([fs, ...]) | 構造器 |
| MfccAccelerationExtractorProcessor.process([data]) | 提取特征 |
- ZeroCrossingRateExtractorProcessor（過零率）
dcase_util.processors.ZeroCrossingRateExtractorProcessor
| ZeroCrossingRateExtractorProcessor([fs, ...]) | 構造器 |
| ZeroCrossingRateExtractorProcessor.process([data]) | 提取特征 |
- RMSEnergyExtractorProcessor（均方根能量）
dcase_util.processors.RMSEnergyExtractorProcessor
| RMSEnergyExtractorProcessor([fs, ...]) | 構造器 |
| RMSEnergyExtractorProcessor.process([data]) | 提取特征 |
- SpectralCentroidExtractorProcessor（光譜質心）
dcase_util.processors.SpectralCentroidExtractorProcessor
| SpectralCentroidExtractorProcessor([fs, ...]) | 構造器 |
| SpectralCentroidExtractorProcessor.process([data]) | 提取特征 |
8.5 Metadata
MetadataReadingProcessor，dcase_util.processors.MetadataReadingProcessor
| MetadataReadingProcessor(\*args, \*\*kwargs) | 構造器 |
| MetadataReadingProcessor.process([data, ...]) | 讀取元數據 |
8.6 Mixin
ProcessorMixin，dcase_util.processors.ProcessorMixin
| ProcessorMixin(\*args, \*\*kwargs) | 數據處理鏈單元混合 |
| ProcessorMixin.process([data]) | 處理數據 |
| ProcessorMixin.get_processing_chain_item() | 使用當前處理器數據獲取處理鏈項目 |
| ProcessorMixin.push_processing_chain_item(...) | 推送加工鏈項目 |
9. User interfacing
用于輕型用戶界面的實用程序類。
FancyLogger和FancyPrinter提供相同的API，唯一不同的是FancyLogger將輸出到日志系統，FancyPrinter使用標準打印功能將輸出打印到sys.stdout。 當需要以字符串形式輸出時，FancyStringifier可用于一般情況。
9.1 FancyLogger
dcase_util.ui.FancyLogger
使用日志記錄時，此類提供額外的格式。 如果在調用FancyLogger時Python日志記錄尚未初始化，則首先調用dcase_util.utils.setup_logging。
用法示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | 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') |
輸出：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | [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 | |
| FancyLogger() | Logger class |
| FancyLogger.line([data, indent, level]) | Generic line logger |
| FancyLogger.row(\*args, \*\*kwargs) | |
| FancyLogger.title(text[, level]) | Title, logged at info level |
| FancyLogger.section_header(text[, indent, level]) | Section header, logged at info level |
| FancyLogger.sub_header([text, indent, level]) | Sub header |
| FancyLogger.foot([text, time, item_count, ...]) | Footer, logged at info level |
| FancyLogger.data([field, value, unit, ...]) | Data line logger |
| FancyLogger.sep([level, length, indent]) | Horizontal separator, logged at info level |
| FancyLogger.table([cell_data, ...]) | Data table |
| FancyLogger.info([text, indent]) | Info line logger |
| FancyLogger.debug([text, indent]) | Debug line logger |
| FancyLogger.error([text, indent]) | Error line logger |
9.2 FancyPrinter
dcase_util.processors.FancyPrinter
該類向控制臺提供統一格式的狀態打印。
用例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | 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') |
輸出：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 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 | |
| FancyPrinter([colors]) | Printer class |
| FancyPrinter.line([data, indent, level]) | Generic line logger |
| FancyPrinter.row(\*args, \*\*kwargs) | |
| FancyPrinter.title(text[, level]) | Title, logged at info level |
| FancyPrinter.section_header(text[, indent, ...]) | Section header, logged at info level |
| FancyPrinter.sub_header([text, indent, level]) | Sub header |
| FancyPrinter.foot([text, time, item_count, ...]) | Footer, logged at info level |
| FancyPrinter.data([field, value, unit, ...]) | Data line logger |
| FancyPrinter.sep([level, length, indent]) | Horizontal separator, logged at info level |
| FancyPrinter.table([cell_data, ...]) | Data table |
| FancyPrinter.info([text, indent]) | Info line logger |
| FancyPrinter.debug([text, indent]) | Debug line logger |
| FancyPrinter.error([text, indent]) | Error line logger |
9.3 FancyStringifier
dcase_util.processors.FancyStringifier
這個類可以用來產生統一格式的輸出字符串。
| FancyStringifier() | Fancy UI |
| FancyStringifier.title(text) | Title |
| FancyStringifier.section_header(text[, indent]) | Section header |
| FancyStringifier.sub_header([text, indent]) | Sub header |
| FancyStringifier.foot([text, time, ...]) | Footer |
| FancyStringifier.line([field, indent]) | Line |
| FancyStringifier.formatted_value(value[, ...]) | Format value into string. |
| FancyStringifier.data([field, value, unit, ...]) | Data line |
| FancyStringifier.sep([length, indent]) | Horizontal separator |
| FancyStringifier.table([cell_data, ...]) | Data table |
| FancyStringifier.row(\*args, \*\*kwargs) | Table row |
| FancyStringifier.class_name(class_name) | Class name |
10. Units（單元函數與類）
10.1 General function
dcase_util.utils. *
| get_class_inheritors(klass) | 得到從給定的類中繼承的所有類 |
| get_byte_string(num_bytes[, show_bytes]) | 根據語言環境和IEC二進制前綴輸出字節數 |
| check_pkg_resources(package_requirement[, ...]) | |
| is_int(value) | |
| is_float(value) |
- SuppressStdoutAndStderr
dcase_util.utils.SuppressStdoutAndStderr
| SuppressStdoutAndStderr() | Context manager to suppress STDOUT and STDERR |
- VectorRecipeParser
dcase_util.utils.VectorRecipeParser
| VectorRecipeParser([delimiters, default_stream]) |
10.2 File
dcase_util.utils. *
| argument_file_exists(filename) | 參數文件檢查器 |
| filelist_exists(filelist) | 檢查列表中的所有文件是否存在 |
| posix_path(path) | 檢查列表中的所有文件是否存在 |
- Path
dcase_util.utils.Path
| Path([path]) | 路徑的單元 |
| Path.posix([path]) | 將路徑轉換為POSIX格式 |
| Path.posix_to_nt([path]) | 將posix格式的路徑轉換為nt |
| Path.file_list([path, recursive, ...]) | 獲取文件列表 |
| Path.exists([path]) | 檢查路徑是否存在 |
| Path.file_count([path]) | 給定路徑下的文件數量包括子目錄 |
| Path.size_bytes([path]) | 給定路徑下所有文件的總字節數 |
| Path.size_string([path, show_bytes]) | 給定路徑下的所有文件的總數據大小以可讀形式返回 |
| Path.makedirs([path]) | 創建給定的路徑 |
| Path.create(paths) | 創建給定的路徑 |
- ApplicationPaths
dcase_util.utils.ApplicationPaths
| ApplicationPaths([parameter_container]) | 應用程序路徑的實用工具類，根據參數散列自動生成路徑 |
| ApplicationPaths.generate(path_base, structure) | 生成應用程序路徑并將參數散列包含到路徑中 |
| ApplicationPaths.directory_name(prefix, ...) | 生成目錄名稱 |
| ApplicationPaths.save_parameters_to_path(...) | 將參數保存到每個應用程序子目錄 |
| ApplicationPaths.construct_path(path_parts) | 基于路徑部分生成所有組合 |
- FileFormat
dcase_util.utils.FileFormat
| FileFormat | |
| FileFormat.detect(filename[, ...]) | 檢測文件格式 |
| FileFormat.detect_based_on_filename(filename) | 基于文件名檢測文件格式 |
| FileFormat.detect_based_on_content(filename) | 使用python-magic檢測基于內容的文件格式。 |
| FileFormat.validate_label(label) | 根據此類已知的標簽驗證文件格式標簽 |
10.3 Hash
| get_parameter_hash(params) | 獲取給定參數字典的唯一哈希字符串（md5） |
| get_file_hash(filename) | 獲取給定文件的唯一哈希字符串（md5） |
10.4 Logging
| setup_logging | 修飾器類只允許執行一次 |
- DisableLogger
dcase_util.utils.DisableLogger
| DisableLogger |
10.5 Math
dcase_util.utils.SimpleMathStringEvaluator
- SimpleMathStringEvaluator
| SimpleMathStringEvaluator() | 簡單的數學字符串評估器 |
| SimpleMathStringEvaluator.eval(string) | 評估字符串中的數學 |
10.6 Timer
dcase_util.utils.Timer
| Timer() | 定時器類 |
| Timer.start() | 啟動計時器 |
| Timer.stop() | 停止計時器 |
| Timer.elapsed() | 返回自啟動計時器以來的經過時間，以秒為單位 |
| Timer.get_string([elapsed]) | 以字符串格式獲取已用時間 |
10.7 Validator
dcase_util.utils.FieldValidator
| FieldValidator | |
| FieldValidator.process(field) | 測試字段 |
| FieldValidator.is_empty(field) | 測試空字段 |
| FieldValidator.is_number(field) | 測試數字字段 |
| FieldValidator.is_audiofile(field) | 測試音頻字段 |
| FieldValidator.is_list(field) | 測試列表字段，有效分隔符[：;＃] |
| FieldValidator.is_alpha(field[, length]) | 測試長度為1的alpha字段 |
10.8 Example
dcase_util.utils.Example
一些示例數據，便于測試和輔導。
| Example() | 教程示例文件 |
| Example.audio_filename() | |
| Example.acoustic_scene_audio_filename() | |
| Example.audio_container() | |
| Example.event_metadata_container([filename]) | |
| Example.scene_metadata_container([filename]) | |
| Example.tag_metadata_container([filename]) | |
| Example.feature_container([filename]) | |
| Example.feature_repository([filename]) |
總結
以上是生活随笔為你收集整理的dcase_util教程（二）——各单元介绍的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 版本沙皇大热？教你如何counter他！
- 下一篇： DNN、CNN、RNN、LSTM的区别