def load_next_block()

in example/speech-demo/io_func/feat_io.py [0:0]

• 64 lines of code
• 29 McCabe index (conditional complexity)

    def load_next_block(self):
        # if anything left...
        # set_value

        if self.crossed_part:
            self.crossed_part = False
            if not self.by_matrix: #    <--- THERE IS A BUG IN THIS
                return DataReadStream.END_OF_PARTITION
        if self.done:
            return DataReadStream.END_OF_DATA
        if self._end_of_data():
            if self.reader is not None:
                self.reader.Cleanup()
            self.reader = None # cleanup
            self.done = True
            return DataReadStream.END_OF_DATA

        # keep loading features until we pass a partition or EOF

        num_feats = 0
        old_fileIndex = self.fileIndex

        self.utt_id = None

        while num_feats < self.chunk_size:
            if self.split_parts:
                if old_fileIndex != self.fileIndex:
                    self.crossed_part = True
                    break

            if self._end_of_data():
                break

            tup = self._load_fn(self.chunk_size - num_feats)
            if tup is None:
                continue

            (loaded_feat, loaded_label) = tup

            if self.has_labels and loaded_label is None:
                print(sys.stderr, "Missing labels for: ", self.utt_id)
                continue

            numFrames = loaded_feat.shape[0]

            # limit loaded_feat, loaded_label, and numFrames to maximum allowed
            allowed = self.maxFeats - self.totalFrames
            if numFrames > allowed:
                loaded_feat = loaded_feat[0:allowed]
                if self.has_labels:
                    loaded_label = loaded_label[0:allowed]
                numFrames = allowed
                assert(numFrames == loaded_feat.shape[0])

            self.totalFrames += numFrames
            new_num_feats = num_feats + numFrames

            # if the x and y buffers are too small, make bigger ones
            # not possible any more; buffers are always fixed
            """
            if new_num_feats > self.x.shape[0]:
                newx = numpy.zeros((new_num_feats, self.n_ins), dtype=numpy.float32)
                newx[0:num_feats] = self.x[0:num_feats]
                self.x = newx

                if self.has_labels:
                    newy = numpy.zeros((new_num_feats,), dtype=numpy.int32)
                    newy[0:num_feats] = self.y[0:num_feats]
                    self.y = newy
            """

            # place into [num_feats:num_feats+num_loaded]
            self.x[num_feats:new_num_feats] = loaded_feat
            if self.has_labels:
                self.y[num_feats:new_num_feats] = loaded_label

            num_feats = new_num_feats

            if self.by_matrix:
                break

        # if we loaded features, shuffle and copy to shared
        if num_feats != 0:

            if self.shuffle:
                x = self.x[0:num_feats]
                state = self.numpy_rng.get_state()
                self.numpy_rng.shuffle(x)
                self.x[0:num_feats] = x

                if self.has_labels:
                    y = self.y[0:num_feats]
                    self.numpy_rng.set_state(state)
                    self.numpy_rng.shuffle(y)
                    self.y[0:num_feats] = y

            assert(self.x.shape == (self.chunk_size, self.n_ins))
            self.shared_x.set_value(self.x, borrow = True)
            if self.has_labels:
                self.shared_y.set_value(self.y, borrow = True)

            #import hashlib
            #print self.totalFrames, self.x.sum(), hashlib.sha1(self.x.view(numpy.float32)).hexdigest()

            if self.by_matrix:
                self.crossed_part = True

        return num_feats