docs: def make_network(
              allele_encoding_dims,
              kmer_size,
              peptide_amino_acid_encoding,
              embedding_input_dim,
              embedding_output_dim,
              allele_dense_layer_sizes,
              peptide_dense_layer_sizes,
              peptide_allele_merge_method,
              peptide_allele_merge_activation,
              layer_sizes,
              dense_layer_l1_regularization,
              dense_layer_l2_regularization,
              activation,
              init,
              output_activation,
              dropout_probability,
              batch_normalization,
              embedding_init_method,
              locally_connected_layers):
          """
          Helper function to make a keras network for class1 affinity prediction.
          """
  
          # We import keras here to avoid tensorflow debug output, etc. unless we
          # are actually about to use Keras.
  
          from keras.layers import Input
          import keras.layers
          from keras.layers.core import Dense, Flatten, Dropout
          from keras.layers.embeddings import Embedding
          from keras.layers.normalization import BatchNormalization
  
          if peptide_amino_acid_encoding == "embedding":
              peptide_input = Input(
                  shape=(kmer_size,), dtype='int32', name='peptide')
              current_layer = Embedding(
                  input_dim=embedding_input_dim,
                  output_dim=embedding_output_dim,
                  input_length=kmer_size,
                  embeddings_initializer=embedding_init_method,
                  name="peptide_embedding")(peptide_input)
          else:
              peptide_input = Input(
                  shape=(
                      kmer_size,
                      vector_encoding_length(peptide_amino_acid_encoding)),
                  dtype='float32',
                  name='peptide')
              current_layer = peptide_input
  
          inputs = [peptide_input]
  
          kernel_regularizer = None
          l1 = dense_layer_l1_regularization
          l2 = dense_layer_l2_regularization
          if l1 > 0 or l2 > 0:
              kernel_regularizer = keras.regularizers.l1_l2(l1, l2)
  
          for (i, locally_connected_params) in enumerate(locally_connected_layers):
              current_layer = keras.layers.LocallyConnected1D(
                  name="lc_%d" % i,
                  **locally_connected_params)(current_layer)
  
          current_layer = Flatten(name="flattened_0")(current_layer)
  
          for (i, layer_size) in enumerate(peptide_dense_layer_sizes):
              current_layer = Dense(
                  layer_size,
                  name="peptide_dense_%d" % i,
                  kernel_regularizer=kernel_regularizer,
                  activation=activation)(current_layer)
  
          if batch_normalization:
              current_layer = BatchNormalization(name="batch_norm_early")(
                  current_layer)
  
          if dropout_probability:
              current_layer = Dropout(dropout_probability, name="dropout_early")(
                  current_layer)
  
          if allele_encoding_dims:
              allele_input = Input(
                  shape=allele_encoding_dims,
                  dtype='float32',
                  name='allele')
              inputs.append(allele_input)
              allele_embedding_layer = Flatten(name="allele_flat")(allele_input)
  
              for (i, layer_size) in enumerate(allele_dense_layer_sizes):
                  allele_embedding_layer = Dense(
                      layer_size,
                      name="allele_dense_%d" % i,
                      kernel_regularizer=kernel_regularizer,
                      activation=activation)(allele_embedding_layer)
  
              if peptide_allele_merge_method == 'concatenate':
                  current_layer = keras.layers.concatenate([
                      current_layer, allele_embedding_layer
                  ], name="allele_peptide_merged")
              elif peptide_allele_merge_method == 'multiply':
                  current_layer = keras.layers.multiply([
                      current_layer, allele_embedding_layer
                  ], name="allele_peptide_merged")
              else:
                  raise ValueError(
                      "Unsupported peptide_allele_encoding_merge_method: %s"
                      % peptide_allele_merge_method)
  
              if peptide_allele_merge_activation:
                  current_layer = keras.layers.Activation(
                      peptide_allele_merge_activation,
                      name="alelle_peptide_merged_%s" %
                           peptide_allele_merge_activation)(current_layer)
              
          for (i, layer_size) in enumerate(layer_sizes):
              current_layer = Dense(
                  layer_size,
                  activation=activation,
                  kernel_regularizer=kernel_regularizer,
                  name="dense_%d" % i)(current_layer)
  
              if batch_normalization:
                  current_layer = BatchNormalization(name="batch_norm_%d" % i)\
                      (current_layer)
  
              if dropout_probability > 0:
                  current_layer = Dropout(
                      dropout_probability, name="dropout_%d" % i)(current_layer)
  
          output = Dense(
              1,
              kernel_initializer=init,
              activation=output_activation,
              name="output")(current_layer)
          model = keras.models.Model(
              inputs=inputs,
              outputs=[output],
              name="predictor")
          return model