metapredict 3.0.0__tar.gz → 3.0.2__tar.gz

{metapredict-3.0.0 → metapredict-3.0.2}/.gitignore

@@ -5,7 +5,7 @@ __pycache__/
 
 # C extensions
 *.so
-.DS_Store
+*.DS_Store
 *~
 
 metapredict/tests/test_cli/output/*

{metapredict-3.0.0 → metapredict-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: metapredict
-Version: 3.0.0
+Version: 3.0.2
 Summary: A machine learning-based tool for predicting protein disorder.
 Author-email: Ryan Emenecker <remenecker@wustl.edu>
 License: MIT
@@ -22,7 +22,7 @@ Requires-Dist: pytest>=6.1.2; extra == "test"
 
 # metapredict: A machine learning-based tool for predicting protein disorder.
 
-### Last updated November 2024
+### Last updated May 2026
 
 ## Current default version: V3
 In November 2024, we changed the default version of metapredict from V2 to V3. Small increments (3.0.x) may be made as bug fixes or feature enhancements.
@@ -116,7 +116,7 @@ Metapredict can be used in five different ways:
 1. As a stand-alone command-line tool (installable via pip - the code in this repository).
 2. As a Python library for integrating into your favorite bioinformatics pipeline (installable via pip - the code in this repository).
 3. As a web-server for examining disorder predictions on individual sequences found at [https://metapredict.net/](https://metapredict.net/).
-4. *NEW as of August 2022:* as a Google Colab notebook for batch-predicting disorder scores for larger numbers of sequences: [**LINK HERE**](https://colab.research.google.com/github/idptools/metapredict/blob/master/colab/metapredict_colab.ipynb). Performance-wise, batch mode can predict the entire yeast proteome in ~1.5 min using the Colab Notebook and much faster if using a local GPU.
+4. *NEW as of August 2022:* as a Google Colab notebook for batch-predicting disorder scores for larger numbers of sequences: [**LINK HERE**](https://colab.research.google.com/drive/1UOrOxun9i23XDE8lFo_4I89Tw8P3Z1D-?usp=sharing). Performance-wise, batch mode can predict the entire yeast proteome in ~1.5 min using the Colab Notebook and much faster if using a local GPU.
 5. *NEW as of May 2023:* as part of the [ALBATROSS paper](https://www.nature.com/articles/s41592-023-02159-5), we provide a colab notebook for predicting IDRs on a proteome-wide scale [**LINK HERE**](https://colab.research.google.com/github/holehouse-lab/ALBATROSS-colab/blob/main/idrome_constructor/idrome_constructor.ipynb).
 
 ## How to cite

{metapredict-3.0.0 → metapredict-3.0.2}/README.md

@@ -1,6 +1,6 @@
 # metapredict: A machine learning-based tool for predicting protein disorder.
 
-### Last updated November 2024
+### Last updated May 2026
 
 ## Current default version: V3
 In November 2024, we changed the default version of metapredict from V2 to V3. Small increments (3.0.x) may be made as bug fixes or feature enhancements.
@@ -94,7 +94,7 @@ Metapredict can be used in five different ways:
 1. As a stand-alone command-line tool (installable via pip - the code in this repository).
 2. As a Python library for integrating into your favorite bioinformatics pipeline (installable via pip - the code in this repository).
 3. As a web-server for examining disorder predictions on individual sequences found at [https://metapredict.net/](https://metapredict.net/).
-4. *NEW as of August 2022:* as a Google Colab notebook for batch-predicting disorder scores for larger numbers of sequences: [**LINK HERE**](https://colab.research.google.com/github/idptools/metapredict/blob/master/colab/metapredict_colab.ipynb). Performance-wise, batch mode can predict the entire yeast proteome in ~1.5 min using the Colab Notebook and much faster if using a local GPU.
+4. *NEW as of August 2022:* as a Google Colab notebook for batch-predicting disorder scores for larger numbers of sequences: [**LINK HERE**](https://colab.research.google.com/drive/1UOrOxun9i23XDE8lFo_4I89Tw8P3Z1D-?usp=sharing). Performance-wise, batch mode can predict the entire yeast proteome in ~1.5 min using the Colab Notebook and much faster if using a local GPU.
 5. *NEW as of May 2023:* as part of the [ALBATROSS paper](https://www.nature.com/articles/s41592-023-02159-5), we provide a colab notebook for predicting IDRs on a proteome-wide scale [**LINK HERE**](https://colab.research.google.com/github/holehouse-lab/ALBATROSS-colab/blob/main/idrome_constructor/idrome_constructor.ipynb).
 
 ## How to cite

{metapredict-3.0.0 → metapredict-3.0.2}/changelog.md

@@ -1,6 +1,18 @@
 ## Changelog
 This section is a log of recent changes with metapredict. My hope is that as I change things, this section can help you figure out why a change was made and if it will break any of your current workflows. The first major changes were made for the 0.56 release, so tracking will start there. Reasons are not provided for bug fixes for because the reason can assumed to be fixing the bug...
 
+#### V3.0.2 (May 2026)
+Changes:
+
+* Updated `metapredict-caid` and CAID output logic: The default IDR/folded domain binarization now uses an algorithmic approach to decompose IDRs and folded domains, rather than a strict per-residue cutoff. This provides more biologically meaningful domain assignments and better reflects the underlying disorder/folded state segmentation.
+
+
+#### V3.0.1 (November 2024)
+Changes:
+
+* Fixed bug that caused memory issues when running many predictions.
+
+
 #### V3.0 (November 2024)
 Changes:
 

{metapredict-3.0.0 → metapredict-3.0.2}/docs/getting_started.rst

@@ -8,7 +8,7 @@ What is metapredict?
 
 Our goal in building **metapredict** was to develop a robust, accurate, and high-performance predictor of intrinsic disorder that is also easy to install and use. As such, **metapredict** is implemented in Python and can be installed directly via `pip` (see below).
 
-metapredict is ALSO available via a `webserver for single sequence prediction <http://https://metapredict.net>`__ and `a Google Colab notebook for batch prediction <https://colab.research.google.com/github/idptools/metapredict/blob/master/colab/metapredict_colab.ipynb>`__. However, this documentation here focuses on the Python package which provides both a set of Python library functions and a set of command-line tools.
+metapredict is ALSO available via a `webserver for single sequence prediction <http://https://metapredict.net>`__ and `a Google Colab notebook for batch prediction <https://colab.research.google.com/drive/1UOrOxun9i23XDE8lFo_4I89Tw8P3Z1D-?usp=sharing>`__. However, this documentation here focuses on the Python package which provides both a set of Python library functions and a set of command-line tools.
 
 
 Recent metapredict updates and news
@@ -145,7 +145,7 @@ How does metapredict V2 differ from V2-FF
 
 metapredict V2 and V2-FF are identical in terms of predictions and features, with the major difference being that metapredict V2-FF offers batched predictions. Batched predictions are automatically parallelized on either the CPU or GPU. In addition, we rewrote the metapredict domain decomposition algorithm in C to provide a 10-20x improvement in performance for this step.
 
-We note that V2-FF was released after CAID, so the performance reported there is the V2 network performance. Because metapredict V2-FF is implemented in a `Google Colab notebook for batch prediction <https://colab.research.google.com/github/idptools/metapredict/blob/master/colab/metapredict_colab.ipynb>`__ you don't have to take our word for it that it's fast; just upload a proteome and see for yourself! 
+We note that V2-FF was released after CAID, so the performance reported there is the V2 network performance. Because metapredict V2-FF is implemented in a `Google Colab notebook for batch prediction <https://colab.research.google.com/drive/1UOrOxun9i23XDE8lFo_4I89Tw8P3Z1D-?usp=sharing>`__ you don't have to take our word for it that it's fast; just upload a proteome and see for yourself! **Note**: The colab notebook has now been updated to V3. However, all 3 metapredict networks are available for use in the notebook!
 
 What is new as far as the disorder prediction in V3?
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

{metapredict-3.0.0 → metapredict-3.0.2}/docs/usage/command-line.rst

@@ -756,10 +756,18 @@ The third argument specifies the version of Metapredict to use. The options are:
 - ``v2``
 - ``v3``
 
+
 **Example**:
 
 .. code-block:: bash
 
     $ metapredict-caid proteins.fasta output/ v3
 
+CAID Output Binarization: Algorithmic Domain Assignment
+------------------------------------------------------
+
+By default, ``metapredict-caid`` uses an algorithmic approach to assign binary labels for IDRs and folded domains. Instead of applying a strict per-residue disorder score cutoff, metapredict decomposes each sequence into contiguous intrinsically disordered regions (IDRs) and folded domains using a domain segmentation algorithm. This results in more biologically meaningful domain assignments that better reflect the underlying disorder/folded state segmentation.
+
+If you prefer the legacy strict cutoff-based assignment, you can use the ``--use-fixed-cutoff`` flag to specify a threshold for per-residue binarization.
+
 

{metapredict-3.0.0 → metapredict-3.0.2}/metapredict/__init__.py

@@ -121,7 +121,7 @@ def print_performance(seq_len=500, num_seqs=2000, variable_length=False,
     start = time.time()
 
     # carry out prediction.
-    predict(seqs, network=version, force_disable_batch=disable_batch, 
+    predict(seqs, version=version, force_disable_batch=disable_batch, 
         use_device=device, normalized=False, show_progress_bar=verbose,
         round_values=False)
 

metapredict-3.0.2/metapredict/_version.py

@@ -0,0 +1 @@
+__version__ = "3.0.2"

{metapredict-3.0.0 → metapredict-3.0.2}/metapredict/analysis/caid2_analysis.py

@@ -1,3 +1,4 @@
+"""
 # code to carry out the caid2 analsis for Disorder PDB dataset. 
 
 '''
@@ -8,7 +9,7 @@ facing.
 '''
 
 
-"""
+
 #  This is commented out because it requires sklearn. Given that none of the stuff
 #  in the analysis part of metapredict is necessary for users, I'm leaving
 #  stuff back here commenting out to avoid addint sklearn as another dependency. 
@@ -21,6 +22,20 @@ from sklearn.metrics import roc_auc_score, average_precision_score, f1_score, pr
 import math
 import matplotlib.pyplot as plt
 
+def use_domains_function(seq_domain):
+    # domain-based binary classification using DisorderObject
+    cur_sequence = seq_domain.sequence
+    cur_scores = seq_domain.disorder
+
+    # build a per-residue binary mask from the IDR domain boundaries
+    # (boundaries are half-open Python-indexed [start, end) intervals).
+    cur_binary_mask = [0] * len(cur_sequence)
+    for boundary in seq_domain.disordered_domain_boundaries:
+        start, end = boundary[0], boundary[1]
+        for i in range(start, end):
+            cur_binary_mask[i] = 1
+    return cur_binary_mask
+
 def read_caid2_seq_disorder(caid_file='caid2_disorder_pdb.fasta'):
     '''
     
@@ -80,7 +95,10 @@ def stretch(scores, base=0.1, top=0.95):
 
 
 
-def get_metapredict_scores(caid2_seqs_scores, version, cutoff=None, plddt=False, smoothing=None, stretch_scores=False):
+def get_metapredict_scores(caid2_seqs_scores, version, cutoff=None, plddt=False, 
+                           smoothing=None, 
+                           stretch_scores=False, 
+                           use_domains=False):
     '''
     function to get the metapredict scores that match
     to each sequence in the caid2 dataset.
@@ -98,6 +116,8 @@ def get_metapredict_scores(caid2_seqs_scores, version, cutoff=None, plddt=False,
         whether to smooth scores over some window. Default=None (no smoothing)
     stretch_scores : bool
         whether to stretch the scores
+    use_domains : bool
+        whether to use domain-based binary classification
 
     Returns
     --------
@@ -127,7 +147,7 @@ def get_metapredict_scores(caid2_seqs_scores, version, cutoff=None, plddt=False,
     
     # now get metapredict predictions.
     if plddt==False:
-        metapredict_scores = predict(caid2_seqs, version=version)
+        metapredict_scores = predict(caid2_seqs, version=version, return_domains=use_domains)
     else:
         metapredict_scores = predict_pLDDT(caid2_seqs, version=version, return_as_disorder_score=True)
 
@@ -151,12 +171,18 @@ def get_metapredict_scores(caid2_seqs_scores, version, cutoff=None, plddt=False,
     results={}
     for s in metapredict_scores:
         name=s
-        sequence=metapredict_scores[s][0]
-        scores=metapredict_scores[s][1]
-        binary_scores=np.array(scores)
-        binary_scores[binary_scores<cutoff] = 0
-        binary_scores[binary_scores>=cutoff] = 1
-        results[name] = {'sequence':sequence, 'scores':scores, 'binary':binary_scores.astype(int).tolist()}
+        if not use_domains:
+            sequence=metapredict_scores[s][0]
+            scores=metapredict_scores[s][1]
+            binary_scores=np.array(scores)
+            binary_scores[binary_scores<cutoff] = 0
+            binary_scores[binary_scores>=cutoff] = 1
+            results[name] = {'sequence':sequence, 'scores':scores, 'binary':binary_scores.astype(int).tolist()}
+        else:
+            sequence=metapredict_scores[s].sequence
+            scores=metapredict_scores[s].disorder
+            binary_scores=np.array(use_domains_function(metapredict_scores[s]))
+            results[name] = {'sequence':sequence, 'scores':scores, 'binary':binary_scores.astype(int).tolist()}
     return results
 
 
@@ -209,7 +235,8 @@ def calc_mcc(metapredict_scores, caid_scores):
     return mcc_value
 
 def calculate_stats(version='V2', cutoff=None, smoothing=None, stretch_scores=False,
-    evaluation_fasta='caid2_disorder_pdb.fasta'):
+    evaluation_fasta='caid2_disorder_pdb.fasta',
+    use_domains=False):
     '''
     Calculate the AUC, APS, and F1 max
 
@@ -233,6 +260,9 @@ def calculate_stats(version='V2', cutoff=None, smoothing=None, stretch_scores=Fa
         the fasta file to use for evaluation. 
         Default is the caid2_disorder_pdb.fasta
 
+    use_domains : bool
+        Whether to use domain-based binary classification. Default is False (per-residue binary classification)
+
     whether to stretch the scores
 
     Returns
@@ -249,7 +279,7 @@ def calculate_stats(version='V2', cutoff=None, smoothing=None, stretch_scores=Fa
     # get caid dict. 
     caid_vals = read_caid2_seq_disorder(caid_file=evaluation_fasta)
     # do metapredict prediction
-    metapredict_vals = get_metapredict_scores(caid_vals, version, cutoff=cutoff, smoothing=smoothing, stretch_scores=stretch_scores)
+    metapredict_vals = get_metapredict_scores(caid_vals, version, cutoff=cutoff, smoothing=smoothing, stretch_scores=stretch_scores, use_domains=use_domains)
     # get linear values for metapredict and caid
     metapredict_linear = []
     caid_linear = ''
@@ -284,7 +314,8 @@ def calculate_stats(version='V2', cutoff=None, smoothing=None, stretch_scores=Fa
 
 
 
-def print_current_network_accuracy(evaluation='all', additional_networks=None):
+
+def print_current_network_accuracy(evaluation='all', additional_networks=None, use_domains=False):
     '''
     Function to print out the current network accuracies. Just a nice
     one-liner to have sitting around. 
@@ -298,6 +329,9 @@ def print_current_network_accuracy(evaluation='all', additional_networks=None):
     additional_networks : list
         additional networks to test. Must be in the 
         metapredict_networks dictionary in network_parameters.py
+
+    use_domains : bool
+    whether to use domain-based binary classification. Default is False (per-residue binary classification)
     '''
     # list of current networks
     nets=['V1', 'V2', 'V3']
@@ -327,7 +361,8 @@ def print_current_network_accuracy(evaluation='all', additional_networks=None):
 
     # add the results for each network 
     for net in nets:
-        results = calculate_stats(version=net)
+        results = calculate_stats(version=net,
+                                  use_domains=use_domains)
         temp=''
         for result in results:
             temp = temp + f'{result} = {results[result]}, '
@@ -336,4 +371,9 @@ def print_current_network_accuracy(evaluation='all', additional_networks=None):
     # print the results
     print(eval_string)
 
+print('no domains')
+print_current_network_accuracy()
+
+print('with domains')
+print_current_network_accuracy(use_domains=True)
 """

{metapredict-3.0.0 → metapredict-3.0.2}/metapredict/backend/architectures.py

@@ -103,16 +103,9 @@ class BRNN_MtM(nn.Module):
             [batch_dim X sequence_length X num_classes]
         """
 
-        # Set initial states
-        # h0 and c0 dimensions: [num_layers*2 X batch_size X hidden_size]
-        #h0 = torch.zeros(self.num_layers*2,     # *2 for bidirection
-        #                 x.size(0), self.hidden_size).to(self.device)
-        #c0 = torch.zeros(self.num_layers*2,
-        #                 x.size(0), self.hidden_size).to(self.device)
-
         # Forward propagate LSTM
         # out: tensor of shape: [batch_size, seq_length, hidden_size*2]
-        out, (h_n, c_n) = self.lstm(x)
+        out, _ = self.lstm(x)
 
         # Decode the hidden state for each time step    
         fc_out = self.fc(out)
@@ -242,7 +235,7 @@ class BRNN_MtM_lightning(L.LightningModule):
         """
         # Forward propagate LSTM
         # out: tensor of shape: [batch_size, seq_length, lstm_hidden_size*2]
-        out, (h_n, c_n) = self.lstm(x)
+        out, _ = self.lstm(x)
         out = self.layer_norm(out)
         for layer in self.linear_layers:
             out = layer(out)