自顶向下分析一个简单的语音识别系统（七）

上回我们分析了系统网络的基本结构，那么我们的网络又是如何训练的呢？要回答这个问题，我们先得回答我们的数据是如何获得的，这回我们就来分析一下这个过程。

1.调用关系图

数据首先通过Tf_train_ctc类中的set_up_model函数调用datasets.py中的read_datasets函数返回一个DataSet类型的对象，该对象包含处理数据相关的配置信息。然后Tf_train_ctc类使用上一步返回的self.data_sets在run_batches函数中调用DataSet类中的next_batch函数返回一次训练所需的batch。具体调用关系图如下所示：

下面开始结合代码进行详细分析。

2.read_datasets函数

该函数返回一个带有数据处理配置信息的DataSet类型对象，具体代码如下：

def read_datasets(conf_path, sets, numcep, numcontext,
                  thread_count=8):
    data_dir, dataset_config = _get_data_set_dict(conf_path, sets)

    def _read_data_set(config):
        path = os.path.join(data_dir, config['dir_pattern'])
        return DataSet.from_directory(path,
                                      thread_count=thread_count,
                                      batch_size=config['batch_size'],
                                      numcep=numcep,
                                      numcontext=numcontext,
                                      start_idx=config['start_idx'],
                                      limit=config['limit'],
                                      sort=config['sort']
                                      )
    datasets = {name: _read_data_set(dataset_config[name])
                      if name in sets else None
                for name in ('train', 'dev', 'test')}
                #sets传入的值为['train', 'dev', 'test']
    return DataSets(**datasets)

由上面代码可知，其主要调用了_get_data_set_dict函数和DataSet类中的from_directory函数。
_get_data_set_dict函数代码如下图所示：

def _get_data_set_dict(conf_path, sets):
    parser = ConfigParser(os.environ)
    parser.read(conf_path)
    config_header = 'data'
    data_dir = get_data_dir(parser.get(config_header, 'data_dir'))
    data_dict = {}

    if 'train' in sets:
        d = {}
        d['dir_pattern'] = parser.get(config_header, 'dir_pattern_train')
        d['limit'] = parser.getint(config_header, 'n_train_limit')
        d['sort'] = parser.get(config_header, 'sort_train')
        d['batch_size'] = parser.getint(config_header, 'batch_size_train')
        d['start_idx'] = parser.getint(config_header, 'start_idx_init_train')
        data_dict['train'] = d
        logging.debug('Training configuration: %s', str(d))

    if 'dev' in sets:
        d = {}
        d['dir_pattern'] = parser.get(config_header, 'dir_pattern_dev')
        d['limit'] = parser.getint(config_header, 'n_dev_limit')
        d['sort'] = parser.get(config_header, 'sort_dev')
        d['batch_size'] = parser.getint(config_header, 'batch_size_dev')
        d['start_idx'] = parser.getint(config_header, 'start_idx_init_dev')
        data_dict['dev'] = d
        logging.debug('Dev configuration: %s', str(d))

    if 'test' in sets:
        d = {}
        d['dir_pattern'] = parser.get(config_header, 'dir_pattern_test')
        d['limit'] = parser.getint(config_header, 'n_test_limit')
        d['sort'] = parser.get(config_header, 'sort_test')
        d['batch_size'] = parser.getint(config_header, 'batch_size_test')
        d['start_idx'] = parser.getint(config_header, 'start_idx_init_test')
        data_dict['test'] = d
        logging.debug('Test configuration: %s', str(d))

    return data_dir, data_dict

这段代码读入了neural_network.ini配置文件中[data]相关信息，返回了data_dict对象是一个包含有数据处理相关配置信息的dict类型对象，具体如下图所示：

得到配置信息之后，_read_data_set函数通过调用DataSet.from_directory函数获得最终的self.data_sets对象。现在我们来分析from_directory函数。

3.from_directory函数

DataSet类中起主要作用的函数为from_directory函数和next_batch函数。from_directory函数用来从data目录下构建之后需要用到的DataSet对象，具体代码如下：

    def from_directory(cls, dirpath, thread_count, batch_size, numcep, numcontext, start_idx=0, limit=0, sort=None):
        if not os.path.exists(dirpath):
            raise IOError("'%s' does not exist" % dirpath)
        txt_files = txt_filenames(dirpath, start_idx=start_idx, limit=limit, sort=sort)
        if len(txt_files) == 0:
            raise RuntimeError('start_idx=%d and limit=%d arguments result in zero files' % (start_idx, limit))
        return cls(txt_files, thread_count, batch_size, numcep, numcontext)

可以看出这段代码主要是调用txt_filenames返回数据文件的命名列表，具体代码如下:

def txt_filenames(dataset_path, start_idx=0, limit=None, sort='alpha'):
        # Obtain list of txt files
        txt_files = glob(os.path.join(dataset_path, "*.txt"))
        limit = limit or len(txt_files)

        # Optional: sort files to improve padding performance
        if sort not in SORTS:
            raise ValueError('sort must be one of [%s]', SORTS)
        reverse = False
        key = None
        if 'filesize' in sort:
            key = os.path.getsize
        if sort == 'filesize_high_low':
            reverse = True
        elif sort == 'random':
            key = lambda *args: random()
        txt_files = sorted(txt_files, key=key, reverse=reverse)

        return txt_files[start_idx:limit + start_idx]

由上面可以看出，这段代码调用定义好的Sort方法，返回长度为limit的txt_files列表（文件路径）。

4.next_batch函数

通过上面的分析我们可以知道，next_batch函数被Tf_train_ctc类中的run_batches函数调用，返回具体需要训练的数据batch。由于具体的训练过程还没有分析，我们现在只是局部介绍next_batch函数，看看该函数返回了怎样的数据，具体代码如下图所示：

    def next_batch(self, batch_size=None):
        if batch_size is None:
            batch_size = self._batch_size

        end_idx = min(len(self._txt_files), self._start_idx + batch_size)
        idx_list = range(self._start_idx, end_idx)
        txt_files = [self._txt_files[i] for i in idx_list]
        wav_files = [x.replace('.txt', '.wav') for x in txt_files]
        (source, _, target, _) = get_audio_and_transcript(txt_files,
                                                          wav_files,
                                                          self._numcep,
                                                          self._numcontext)

        self._start_idx += batch_size
        # Verify that the start_idx is not larger than total available sample size
        if self._start_idx >= self.size:
            self._start_idx = 0

        # Pad input to max_time_step of this batch
        source, source_lengths = pad_sequences(source)
        sparse_labels = sparse_tuple_from(target)
        return source, source_lengths, sparse_labels

由代码中可以看出每次取出batch_size个训练数据，同时要求每个训练数据的文本txt的名字与波形文件wav的名字保持相同。该函数主要调用get_audio_and_transcript函数、pad_sequences函数和sparse_tuple_from函数，这三个函数分别属于load_audio_to_mem.py和text.py中，负责具体获得相关的输入输出向量，留待下回分解。