net.py 文件源码

def create_predictive_net(self) -> Sequential:
        """Returns the part of the net that predicts grapheme probabilities given a spectrogram.
         A loss operation is not contained.
         As described here: https://arxiv.org/pdf/1609.03193v2.pdf
        """

        def convolution(name: str, filter_count: int, filter_length: int, strides: int = 1,
                        activation: str = self.activation,
                        input_dim: int = None,
                        never_dropout: bool = False) -> List[Layer]:
            return ([] if self.dropout is None or never_dropout else [
                Dropout(self.dropout, input_shape=(None, input_dim),
                        name="dropout_before_{}".format(name))]) + [
                       Conv1D(filters=filter_count, kernel_size=filter_length, strides=strides,
                              activation=activation, name=name, input_shape=(None, input_dim), padding="same")]

        main_filter_count = 250

        def input_convolutions() -> List[Conv1D]:
            raw_wave_convolution_if_needed = convolution(
                "wave_conv", filter_count=main_filter_count, filter_length=250, strides=160,
                input_dim=self.input_size_per_time_step) if self.use_raw_wave_input else []

            return raw_wave_convolution_if_needed + convolution(
                "striding_conv", filter_count=main_filter_count, filter_length=48, strides=2,
                input_dim=None if self.use_raw_wave_input else self.input_size_per_time_step)

        def inner_convolutions() -> List[Conv1D]:
            return [layer for i in
                    range(1, 8) for layer in
                    convolution("inner_conv_{}".format(i), filter_count=main_filter_count, filter_length=7)]

        def output_convolutions() -> List[Conv1D]:
            out_filter_count = 2000
            return [layer for conv in [
                convolution("big_conv_1", filter_count=out_filter_count, filter_length=32, never_dropout=True),
                convolution("big_conv_2", filter_count=out_filter_count, filter_length=1, never_dropout=True),
                convolution("output_conv", filter_count=self.grapheme_encoding.grapheme_set_size,
                            filter_length=1,
                            activation=self.output_activation, never_dropout=True)
            ] for layer in conv]

        layers = input_convolutions() + inner_convolutions() + output_convolutions()

        if self.frozen_layer_count > 0:
            log("All but {} layers frozen.".format(len(layers) - self.frozen_layer_count))

        for layer in layers[:self.frozen_layer_count]:
            layer.trainable = False

        return Sequential(layers)