docs: def fit_allele_specific_predictors(
              self,
              n_models,
              architecture_hyperparameters_list,
              allele,
              peptides,
              affinities,
              inequalities=None,
              train_rounds=None,
              models_dir_for_save=None,
              verbose=0,
              progress_preamble="",
              progress_print_interval=5.0):
          """
          Fit one or more allele specific predictors for a single allele using one
          or more neural network architectures.
          
          The new predictors are saved in the Class1AffinityPredictor instance
          and will be used on subsequent calls to `predict`.
          
          Parameters
          ----------
          n_models : int
              Number of neural networks to fit
          
          architecture_hyperparameters_list : list of dict
              List of hyperparameter sets.
                 
          allele : string
          
          peptides : `EncodableSequences` or list of string
          
          affinities : list of float
              nM affinities
  
          inequalities : list of string, each element one of ">", "<", or "="
              See Class1NeuralNetwork.fit for details.
  
          train_rounds : sequence of int
              Each training point i will be used on training rounds r for which
              train_rounds[i] > r, r >= 0.
          
          models_dir_for_save : string, optional
              If specified, the Class1AffinityPredictor is (incrementally) written
              to the given models dir after each neural network is fit.
          
          verbose : int
              Keras verbosity
  
          progress_preamble : string
              Optional string of information to include in each progress update
  
          progress_print_interval : float
              How often (in seconds) to print progress. Set to None to disable.
  
          Returns
          -------
          list of `Class1NeuralNetwork`
          """
  
          allele = mhcnames.normalize_allele_name(allele)
          if allele not in self.allele_to_allele_specific_models:
              self.allele_to_allele_specific_models[allele] = []
  
          encodable_peptides = EncodableSequences.create(peptides)
          peptides_affinities_inequalities_per_round = [
              (encodable_peptides, affinities, inequalities)
          ]
  
          if train_rounds is not None:
              for round in sorted(set(train_rounds)):
                  round_mask = train_rounds > round
                  if round_mask.any():
                      sub_encodable_peptides = EncodableSequences.create(
                          encodable_peptides.sequences[round_mask])
                      peptides_affinities_inequalities_per_round.append((
                          sub_encodable_peptides,
                          affinities[round_mask],
                          None if inequalities is None else inequalities[round_mask]))
          n_rounds = len(peptides_affinities_inequalities_per_round)
  
          n_architectures = len(architecture_hyperparameters_list)
  
          # Adjust progress info to indicate number of models and
          # architectures.
          pieces = []
          if n_models > 1:
              pieces.append("Model {model_num:2d} / {n_models:2d}")
          if n_architectures > 1:
              pieces.append(
                  "Architecture {architecture_num:2d} / {n_architectures:2d}")
          if len(peptides_affinities_inequalities_per_round) > 1:
              pieces.append("Round {round:2d} / {n_rounds:2d}")
          pieces.append("{n_peptides:4d} peptides")
          progress_preamble_template = "[ %s ] {user_progress_preamble}" % (
              ", ".join(pieces))
  
          models = []
          for model_num in range(n_models):
              for (architecture_num, architecture_hyperparameters) in enumerate(
                      architecture_hyperparameters_list):
                  model = Class1NeuralNetwork(**architecture_hyperparameters)
                  for round_num in range(n_rounds):
                      (round_peptides, round_affinities, round_inequalities) = (
                          peptides_affinities_inequalities_per_round[round_num]
                      )
                      model.fit(
                          round_peptides,
                          round_affinities,
                          inequalities=round_inequalities,
                          verbose=verbose,
                          progress_preamble=progress_preamble_template.format(
                              n_peptides=len(round_peptides),
                              round=round_num,
                              n_rounds=n_rounds,
                              user_progress_preamble=progress_preamble,
                              model_num=model_num + 1,
                              n_models=n_models,
                              architecture_num=architecture_num + 1,
                              n_architectures=n_architectures),
                          progress_print_interval=progress_print_interval)
  
                  model_name = self.model_name(allele, model_num)
                  row = pandas.Series(collections.OrderedDict([
                      ("model_name", model_name),
                      ("allele", allele),
                      ("config_json", json.dumps(model.get_config())),
                      ("model", model),
                  ])).to_frame().T
                  self._manifest_df = pandas.concat(
                      [self.manifest_df, row], ignore_index=True)
                  self.allele_to_allele_specific_models[allele].append(model)
                  if models_dir_for_save:
                      self.save(
                          models_dir_for_save, model_names_to_write=[model_name])
                  models.append(model)
  
          self.clear_cache()
          return models