Newer
Older
import sklearn
import sklearn.linear_model
try:
import tqdm
except ImportError:
tdqm = None
from .class1_affinity_predictor import Class1AffinityPredictor
from .class1_processing_predictor import Class1ProcessingPredictor
from .class1_neural_network import DEFAULT_PREDICT_BATCH_SIZE
from .downloads import get_default_class1_presentation_models_dir
MAX_ALLELES_PER_SAMPLE = 6
PREDICT_BATCH_SIZE = DEFAULT_PREDICT_BATCH_SIZE
PREDICT_CHUNK_SIZE = 100000 # currently used only for cleavage prediction
"""
A logistic regression model over predicted binding affinity (BA) and antigen
processing (AP) score.
Instances of this class delegate to Class1AffinityPredictor and
Class1ProcessingPredictor instances to generate BA and AP predictions.
These predictions are combined using a logistic regression model to give
a "presentation score" prediction.
Most users will call the `load` static method to get an instance of this
class, then call the `predict_to_dataframe` method to generate predictions.
model_inputs = ["affinity_score", "processing_score"]
processing_predictor_with_flanks=None,
processing_predictor_without_flanks=None,
self.affinity_predictor = affinity_predictor
self.processing_predictor_with_flanks = processing_predictor_with_flanks
self.processing_predictor_without_flanks = processing_predictor_without_flanks
self.weights_dataframe = weights_dataframe
self.metadata_dataframes = (
dict(metadata_dataframes) if metadata_dataframes else {})
@property
def supported_alleles(self):
"""
List of alleles supported by the underlying Class1AffinityPredictor
"""
return self.affinity_predictor.supported_alleles
@property
def supported_peptide_lengths(self):
"""
(min, max) of supported peptide lengths, inclusive.
"""
return self.affinity_predictor.supported_peptide_lengths
def predict_affinity(
self,
peptides,
alleles,
include_affinity_percentile=False,
verbose=1,
throw=True):
Predict binding affinities across samples (each corresponding to up to
six MHC I alleles).
Two modes are supported: each peptide can be evaluated for binding to
any of the alleles in any sample (this is what happens when sample_names
is None), or the i'th peptide can be evaluated for binding the alleles
of the sample given by the i'th entry in sample_names.
For example, if we don't specify sample_names, then predictions
are taken for all combinations of samples and peptides, for a result
size of num peptides * num samples:
>>> predictor = Class1PresentationPredictor.load()
>>> predictor.predict_affinity(
... peptides=["SIINFEKL", "PEPTIDE"],
... alleles={
... "sample1": ["A0201", "A0301", "B0702"],
... "sample2": ["A0101", "C0202"],
... },
... verbose=0)
peptide peptide_num sample_name affinity best_allele
0 SIINFEKL 0 sample1 12906.787792 A0201
1 PEPTIDE 1 sample1 36827.681130 B0702
2 SIINFEKL 0 sample2 3588.413748 C0202
3 PEPTIDE 1 sample2 34362.109211 C0202
In contrast, here we specify sample_names, so peptide is evaluated for
binding the alleles in the corresponding sample, for a result size equal
to the number of peptides:
>>> predictor.predict_affinity(
... peptides=["SIINFEKL", "PEPTIDE"],
... alleles={
... "sample1": ["A0201", "A0301", "B0702"],
... "sample2": ["A0101", "C0202"],
... },
... sample_names=["sample2", "sample1"],
... verbose=0)
peptide peptide_num sample_name affinity best_allele
0 SIINFEKL 0 sample2 3588.412141 C0202
1 PEPTIDE 1 sample1 36827.682779 B0702
alleles : dict of string -> list of string
Keys are sample names, values are the alleles (genotype) for
Sample names corresponding to each peptide. If None, then
predictions are generated for all sample genotypes across all
peptides.
include_affinity_percentile : bool
Whether to include affinity percentile ranks
verbose : int
Set to 0 for quiet.
throw : verbose
Whether to throw exception (vs. just log a warning) on invalid
peptides, etc.
df = pandas.DataFrame({
"peptide": numpy.array(peptides, copy=False),
})
df["peptide_num"] = df.index
peptides = EncodableSequences.create(peptides)
all_alleles = set()
for lst in alleles.values():
all_alleles.update(lst)
iterator = sorted(all_alleles)
if verbose > 0:
print("Predicting affinities.")
if tqdm is not None:
iterator = tqdm.tqdm(iterator, total=len(all_alleles))
predictions_df = pandas.DataFrame(index=df.index)
for allele in iterator:
predictions_df[allele] = self.affinity_predictor.predict(
model_kwargs={'batch_size': PREDICT_BATCH_SIZE},
throw=throw)
if len(df) == 0:
new_df["best_allele"] = []
else:
new_df["best_allele"] = predictions_df[
].idxmin(1).values
dfs.append(new_df)
result_df = pandas.concat(dfs, ignore_index=True)
else:
df["sample_name"] = numpy.array(sample_names, copy=False)
if verbose > 0:
print("Predicting affinities.")
if tqdm is not None:
iterator = tqdm.tqdm(
sample_peptides = EncodableSequences.create(sub_df.peptide.values)
for allele in alleles[sample]:
predictions_df[allele] = self.affinity_predictor.predict(
allele=allele,
model_kwargs={'batch_size': PREDICT_BATCH_SIZE},
throw=throw)
df.loc[
sub_df.index, "affinity"
] = predictions_df.min(1).values
df.loc[
sub_df.index, "best_allele"
] = predictions_df.idxmin(1).values
result_df = df
if include_affinity_percentile:
result_df["affinity_percentile"] = (
self.affinity_predictor.percentile_ranks(
result_df.affinity.values,
alleles=result_df.best_allele.values,
self, peptides, n_flanks=None, c_flanks=None, verbose=1):
"""
Predict antigen processing scores for individual peptides, optionally
including flanking sequences for better cleavage prediction.
Parameters
----------
peptides : list of string
n_flanks : list of string [same length as peptides]
c_flanks : list of string [same length as peptides]
verbose : int
Returns
-------
numpy.array : Antigen processing scores for each peptide
"""
if (n_flanks is None) != (c_flanks is None):
raise ValueError("Specify both or neither of n_flanks, c_flanks")
if n_flanks is None:
if self.processing_predictor_without_flanks is None:
raise ValueError("No processing predictor without flanks")
predictor = self.processing_predictor_without_flanks
n_flanks = [""] * len(peptides)
c_flanks = n_flanks
else:
if self.processing_predictor_with_flanks is None:
raise ValueError("No processing predictor with flanks")
predictor = self.processing_predictor_with_flanks
if len(peptides) == 0:
return numpy.array([], dtype=float)
num_chunks = int(numpy.ceil(float(len(peptides)) / PREDICT_CHUNK_SIZE))
peptide_chunks = numpy.array_split(peptides, num_chunks)
n_flank_chunks = numpy.array_split(n_flanks, num_chunks)
c_flank_chunks = numpy.array_split(c_flanks, num_chunks)
iterator = zip(peptide_chunks, n_flank_chunks, c_flank_chunks)
if verbose > 0:
print("Predicting processing.")
if tqdm is not None:
iterator = tqdm.tqdm(iterator, total=len(peptide_chunks))
result_chunks = []
for (peptide_chunk, n_flank_chunk, c_flank_chunk) in iterator:
result_chunk = predictor.predict(
peptides=peptide_chunk,
n_flanks=n_flank_chunk,
c_flanks=c_flank_chunk,
batch_size=PREDICT_BATCH_SIZE)
result_chunks.append(result_chunk)
return numpy.concatenate(result_chunks)
def fit(
self,
targets,
peptides,
alleles,
n_flanks=None,
c_flanks=None,
verbose=1):
"""
Fit the presentation score logistic regression model.
Parameters
----------
targets : list of int/float
1 indicates hit, 0 indicates decoy
peptides : list of string [same length as targets]
Keys are sample names, values are the alleles for that sample
n_flanks : list of string [same length as targets]
c_flanks : list of string [same length as targets]
verbose : int
"""
peptides=peptides,
alleles=alleles,
df["affinity_score"] = from_ic50(df.affinity)
df["target"] = numpy.array(targets, copy=False)
if (n_flanks is None) != (c_flanks is None):
raise ValueError("Specify both or neither of n_flanks, c_flanks")
with_flanks_list = []
if self.processing_predictor_without_flanks is not None:
if n_flanks is not None and self.processing_predictor_with_flanks is not None:
with_flanks_list.append(True)
if not with_flanks_list:
raise RuntimeError("Can't fit any models")
if self.weights_dataframe is None:
self.weights_dataframe = pandas.DataFrame()
for with_flanks in with_flanks_list:
model_name = 'with_flanks' if with_flanks else "without_flanks"
if verbose > 0:
print("Training variant", model_name)
df["processing_score"] = self.predict_processing(
peptides=df.peptide.values,
n_flanks=n_flanks if with_flanks else None,
c_flanks=c_flanks if with_flanks else None,
verbose=verbose)
model = self.get_model()
if verbose > 0:
print("Fitting LR model.")
print(df)
model.fit(
X=df[self.model_inputs].values,
y=df.target.astype(float))
self.weights_dataframe.loc[model_name, "intercept"] = model.intercept_
for (name, value) in zip(self.model_inputs, numpy.squeeze(model.coef_)):
self.weights_dataframe.loc[model_name, name] = value
self._models_cache[model_name] = model
def get_model(self, name=None):
"""
Load or instantiate a new logistic regression model. Private helper
method.
Parameters
----------
name : string
If None (the default), an un-fit LR model is returned. Otherwise the
weights are loaded for the specified model.
Returns
-------
sklearn.linear_model.LogisticRegression
"""
if name is None or name not in self._models_cache:
model = sklearn.linear_model.LogisticRegression(solver="lbfgs")
if name is not None:
row = self.weights_dataframe.loc[name]
model.intercept_ = row.intercept
model.coef_ = numpy.expand_dims(
row[self.model_inputs].values, axis=0)
else:
model = self._models_cache[name]
return model
def predict(
self,
peptides,
alleles,
"""
Predict presentation scores across a set of peptides.
Presentation scores combine predictions for MHC I binding affinity
and antigen processing.
For intermediate results, see the `predict_to_dataframe` method.
If you are predicting for a single sample, pass a list of strings
(up to 6) indicating the genotype. If you are predicting across
multiple samples, pass a dict where the keys are (arbitrary)
sample names and the values are the alleles to predict for that
If you are passing a dict for 'alleles', use this argument to
n_flanks : list of string [same length as peptides]
Upstream sequences before the peptide. Sequences of any length can
be given and a suffix of the size supported by the model will be
used.
c_flanks : list of string [same length as peptides]
Downstream sequences after the peptide. Sequences of any length can
be given and a prefix of the size supported by the model will be
used.
verbose : int
Set to 0 for quiet mode.
Presentation scores for each peptide. Scores range from 0 to 1, with
higher values indicating more favorable presentation likelihood.
if isinstance(alleles, dict):
"sample_names must be supplied when alleles is a dict. "
"Alternatively, call predict_to_dataframe to predict over "
return self.predict_to_dataframe(
peptides=peptides,
alleles=alleles,
verbose=verbose).presentation_score.values
def predict_to_dataframe(
self,
peptides,
alleles,
n_flanks=None,
c_flanks=None,
include_affinity_percentile=False,
verbose=1,
throw=True):
"""
Predict presentation scores across a set of peptides.
Presentation scores combine predictions for MHC I binding affinity
and antigen processing.
This method returns a pandas.DataFrame giving presentation scores plus
the binding affinity and processing predictions and other intermediate
results.
Example:
>>> predictor = Class1PresentationPredictor.load()
>>> predictor.predict_to_dataframe(
... peptides=["SIINFEKL", "PEPTIDE"],
... n_flanks=["NNN", "SNS"],
... c_flanks=["CCC", "CNC"],
... alleles={
... "sample1": ["A0201", "A0301", "B0702"],
... "sample2": ["A0101", "C0202"],
... },
... verbose=0)
peptide n_flank c_flank peptide_num sample_name affinity best_allele processing_score presentation_score
0 SIINFEKL NNN CCC 0 sample1 12906.787792 A0201 0.802466 0.140365
1 PEPTIDE SNS CNC 1 sample1 36827.681130 B0702 0.105260 0.004059
2 SIINFEKL NNN CCC 0 sample2 3588.413748 C0202 0.802466 0.338647
3 PEPTIDE SNS CNC 1 sample2 34362.109211 C0202 0.105260 0.004317
You can also specify sample_names, in which case peptide is evaluated
for binding the alleles in the corresponding sample only. See
`predict_affinity` for an examples.
Parameters
----------
peptides : list of string
Peptide sequences
If you are predicting for a single sample, pass a list of strings
(up to 6) indicating the genotype. If you are predicting across
multiple samples, pass a dict where the keys are (arbitrary)
sample names and the values are the alleles to predict for that
sample_names : list of string [same length as peptides]
If you are passing a dict for 'alleles', you can use this
argument to specify which peptides go with which samples. If it is
None, then predictions will be performed for each peptide across all
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
n_flanks : list of string [same length as peptides]
Upstream sequences before the peptide. Sequences of any length can
be given and a suffix of the size supported by the model will be
used.
c_flanks : list of string [same length as peptides]
Downstream sequences after the peptide. Sequences of any length can
be given and a prefix of the size supported by the model will be
used.
include_affinity_percentile : bool
Whether to include affinity percentile ranks
verbose : int
Set to 0 for quiet.
throw : verbose
Whether to throw exception (vs. just log a warning) on invalid
peptides, etc.
Returns
-------
pandas.DataFrame
Presentation scores and intermediate results.
"""
if isinstance(peptides, string_types):
raise TypeError("peptides must be a list not a string")
if isinstance(alleles, string_types):
raise TypeError("alleles must be a list or dict")
if not isinstance(alleles, dict):
# Make alleles into a dict.
"alleles must be a dict when sample_names is specified")
alleles = numpy.array(alleles, copy=False)
if len(alleles) > MAX_ALLELES_PER_SAMPLE:
raise ValueError(
"When alleles is a list, it must have at most %d elements. "
"These alleles are taken to be a genotype for an "
"individual, and the strongest prediction across alleles "
"will be taken for each peptide. Note that this differs "
"from Class1AffinityPredictor.predict(), where alleles "
"is expected to be the same length as peptides."
% MAX_ALLELES_PER_SAMPLE)
alleles = {
}
if (n_flanks is None) != (c_flanks is None):
raise ValueError("Specify both or neither of n_flanks, c_flanks")
processing_scores = self.predict_processing(
peptides=peptides,
n_flanks=n_flanks,
c_flanks=c_flanks,
verbose=verbose)
df = self.predict_affinity(
peptides=peptides,
alleles=alleles,
include_affinity_percentile=include_affinity_percentile,
verbose=verbose,
throw=throw)
df["processing_score"] = df.peptide_num.map(
pandas.Series(processing_scores))
df.insert(1, "c_flank", df.peptide_num.map(pandas.Series(c_flanks)))
df.insert(1, "n_flank", df.peptide_num.map(pandas.Series(n_flanks)))
model_name = 'with_flanks' if n_flanks is not None else "without_flanks"
model = self.get_model(model_name)
if len(df) > 0:
df["presentation_score"] = model.predict_proba(
df[self.model_inputs].values)[:,1]
else:
df["presentation_score"] = []
self,
sequences,
alleles,
comparison_quantity="presentation_score",
peptide_lengths=(8, 9, 10, 11),
include_affinity_percentile=True,
verbose=1,
throw=True):
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
Example:
>>> predictor = Class1PresentationPredictor.load()
>>> predictor.predict_sequences(
... sequences={
... 'protein1': "MDSKGSSQKGSRLLLLLVVSNLL",
... 'protein2': "SSLPTPEDKEQAQQTHH",
... },
... alleles={
... "sample1": ["A0201", "A0301", "B0702"],
... "sample2": ["A0101", "C0202"],
... },
... result="filtered",
... comparison_quantity="affinity",
... filter_value=500,
... verbose=0)
sequence_name pos peptide n_flank c_flank sample_name affinity best_allele affinity_percentile processing_score presentation_score
0 protein1 13 LLLLVVSNL MDSKGSSQKGSRL L sample1 38.206225 A0201 0.380125 0.017644 0.571060
1 protein1 14 LLLVVSNLL MDSKGSSQKGSRLL sample1 42.243472 A0201 0.420250 0.090984 0.619213
2 protein1 5 SSQKGSRLL MDSKG LLLVVSNLL sample2 66.749223 C0202 0.803375 0.383608 0.774468
3 protein1 6 SQKGSRLLL MDSKGS LLVVSNLL sample2 178.033474 C0202 1.820000 0.275019 0.482206
4 protein1 13 LLLLVVSNLL MDSKGSSQKGSRL sample1 202.208167 A0201 1.112500 0.058782 0.261320
5 protein1 12 LLLLLVVSNL MDSKGSSQKGSR L sample1 202.506582 A0201 1.112500 0.010025 0.225648
6 protein2 0 SSLPTPEDK EQAQQTHH sample1 335.529377 A0301 1.011750 0.010443 0.156798
7 protein2 0 SSLPTPEDK EQAQQTHH sample2 353.451759 C0202 2.674250 0.010443 0.150753
8 protein1 8 KGSRLLLLL MDSKGSSQ VVSNLL sample2 410.327286 C0202 2.887000 0.121374 0.194081
9 protein1 5 SSQKGSRL MDSKG LLLLVVSNLL sample2 477.285954 C0202 3.107375 0.111982 0.168572
Parameters
----------
sequences : str, list of string, or string -> string dict
Protein sequences. If a dict is given, the keys are arbitrary (
e.g. protein names), and the values are the amino acid sequences.
alleles : list of string, list of list of string, or dict of string -> list of string
MHC I alleles. Can be: (1) a string (a single allele), (2) a list of
strings (a single genotype), (3) a list of list of strings
(multiple genotypes, where the total number of genotypes must equal
the number of sequences), or (4) a dict giving multiple genotypes,
which will each be run over the sequences.
Specify 'best' to return the strongest peptide for each sequence,
'all' to return predictions for all peptides, or 'filtered' to
return predictions where the comparison_quantity is stronger
(i.e (<) for affinity, (>) for scores) than filter_value.
One of "presentation_score", "processing_score", "affinity", or
"affinity_percentile". Prediction to use to rank (if result is
"best") or filter (if result is "filtered") results.
filter_value : float
Threshold value to use, only relevant when result is "filtered".
If comparison_quantity is "affinity", then all results less than
(i.e. tighter than) the specified nM affinity are retained. If it's
"presentation_score" or "processing_score" then results greater than
the indicated filter_value are retained.
peptide_lengths : list of int
Peptide lengths to predict for.
use_flanks : bool
Whether to include flanking sequences when running the AP predictor
(for better cleavage prediction).
include_affinity_percentile : bool
Whether to include affinity percentile ranks in output.
verbose : int
Set to 0 for quiet mode.
throw : boolean
Whether to throw exceptions (vs. log warnings) on invalid inputs.
Returns
-------
pandas.DataFrame with columns:
peptide, n_flank, c_flank, sequence_name, affinity, best_allele,
processing_score, presentation_score
"""
if comparison_quantity is None:
comparison_quantity = "presentation_score"
processing_predictor = self.processing_predictor_with_flanks
if not use_flanks or processing_predictor is None:
processing_predictor = self.processing_predictor_without_flanks
supported_sequence_lengths = processing_predictor.sequence_lengths
n_flank_length = supported_sequence_lengths["n_flank"]
c_flank_length = supported_sequence_lengths["c_flank"]
sequence_names = []
n_flanks = [] if use_flanks else None
c_flanks = [] if use_flanks else None
peptides = []
if isinstance(sequences, string_types):
sequences = [sequences]
if not isinstance(sequences, dict):
sequences = collections.OrderedDict(
("sequence_%04d" % (i + 1), sequence)
for (i, sequence) in enumerate(sequences))
# Case (1) - alleles is a string
if isinstance(alleles, dict):
if any([isinstance(v, string_types) for v in alleles.values()]):
"The values in the alleles dict must be lists, not strings")
else:
if all(isinstance(a, string_types) for a in alleles):
# Case (2) - a simple list of alleles
alleles = {
# Case (3) - a list of lists
alleles = collections.OrderedDict(
("genotype_%04d" % (i + 1), genotype)
for (i, genotype) in enumerate(alleles))
cross_product = False
if len(alleles) != len(sequences):
raise ValueError(
"When passing a list of lists for the alleles argument "
"the length of the list (%d) must match the length of "
"the sequences being predicted (%d)" % (
len(alleles), len(sequences)))
if not isinstance(alleles, dict):
raise ValueError("Invalid type for alleles: ", type(alleles))
genotype_names = list(alleles)
position_in_sequence = []
for (i, (name, sequence)) in enumerate(sequences.items()):
genotype_name = None if cross_product else genotype_names[i]
if not isinstance(sequence, string_types):
raise ValueError("Expected string, not %s (%s)" % (
sequence, type(sequence)))
for peptide_start in range(len(sequence) - min(peptide_lengths) + 1):
n_flank_start = max(0, peptide_start - n_flank_length)
for peptide_length in peptide_lengths:
peptide = sequence[
peptide_start: peptide_start + peptide_length
]
if len(peptide) != peptide_length:
continue
c_flank_end = (
peptide_start + peptide_length + c_flank_length)
sequence_names.append(name)
position_in_sequence.append(peptide_start)
if not cross_product:
if use_flanks:
n_flanks.append(
sequence[n_flank_start : peptide_start])
c_flanks.append(
sequence[peptide_start + peptide_length : c_flank_end])
result_df = self.predict_to_dataframe(
peptides=peptides,
alleles=alleles,
n_flanks=n_flanks,
c_flanks=c_flanks,
include_affinity_percentile=include_affinity_percentile,
verbose=verbose,
throw=throw)
result_df.insert(
0,
"sequence_name",
result_df.peptide_num.map(pandas.Series(sequence_names)))
result_df.insert(
1,
result_df.peptide_num.map(pandas.Series(position_in_sequence)))
del result_df["peptide_num"]
comparison_is_score = comparison_quantity.endswith("score")
result_df = result_df.sort_values(
comparison_quantity,
ascending=not comparison_is_score)
if result == "best":
result_df = result_df.drop_duplicates(
).sort_values("sequence_name")
elif result == "filtered":
if comparison_is_score:
result_df = result_df.loc[
]
else:
result_df = result_df.loc[
]
elif result == "all":
pass
else:
raise ValueError(
"Unknown result: %s. Valid choices are: best, filtered, all"
% result)
result_df = result_df.reset_index(drop=True)
result_df = result_df.copy()
return result_df
Save the predictor to a directory on disk. If the directory does
The wrapped Class1AffinityPredictor and Class1ProcessingPredictor
instances are included in the saved data.
Parameters
----------
models_dir : string
Path to directory. It will be created if it doesn't exist.
"""
if self.weights_dataframe is None:
raise RuntimeError("Can't save before fitting")
# Save underlying predictors
self.affinity_predictor.save(join(models_dir, "affinity_predictor"))
if self.processing_predictor_with_flanks is not None:
self.processing_predictor_with_flanks.save(
join(models_dir, "processing_predictor_with_flanks"))
if self.processing_predictor_without_flanks is not None:
self.processing_predictor_without_flanks.save(
join(models_dir, "processing_predictor_without_flanks"))
# Save model coefficients.
self.weights_dataframe.to_csv(join(models_dir, "weights.csv"))
# Write "info.txt"
info_path = join(models_dir, "info.txt")
rows = [
("trained on", time.asctime()),
("package ", "mhcflurry %s" % __version__),
("hostname ", gethostname()),
("user ", getuser()),
]
pandas.DataFrame(rows).to_csv(
info_path, sep="\t", header=False, index=False)
if self.metadata_dataframes:
for (name, df) in self.metadata_dataframes.items():
metadata_df_path = join(models_dir, "%s.csv.bz2" % name)
df.to_csv(metadata_df_path, index=False, compression="bz2")
@classmethod
def load(cls, models_dir=None, max_models=None):
This will also load the wrapped Class1AffinityPredictor and
Class1ProcessingPredictor instances.
Parameters
----------
models_dir : string
Path to directory. If unspecified the default downloaded models are
used.
max_models : int, optional
Maximum number of affinity and processing (counted separately)
`Class1PresentationPredictor` instance
models_dir = get_default_class1_presentation_models_dir()
affinity_predictor = Class1AffinityPredictor.load(
join(models_dir, "affinity_predictor"), max_models=max_models)
processing_predictor_with_flanks = None
if exists(join(models_dir, "processing_predictor_with_flanks")):
processing_predictor_with_flanks = Class1ProcessingPredictor.load(
join(models_dir, "processing_predictor_with_flanks"),
else:
logging.warning(
"Presentation predictor is missing processing predictor: %s",
join(models_dir, "processing_predictor_with_flanks"))
processing_predictor_without_flanks = None
if exists(join(models_dir, "processing_predictor_without_flanks")):
processing_predictor_without_flanks = Class1ProcessingPredictor.load(
join(models_dir, "processing_predictor_without_flanks"),
else:
logging.warning(
"Presentation predictor is missing processing predictor: %s",
join(models_dir, "processing_predictor_without_flanks"))
weights_dataframe = pandas.read_csv(
join(models_dir, "weights.csv"),
index_col=0)
affinity_predictor=affinity_predictor,
processing_predictor_with_flanks=processing_predictor_with_flanks,
processing_predictor_without_flanks=processing_predictor_without_flanks,
weights_dataframe=weights_dataframe)