Migrated from GitHub

.gitattributes

@@ -57,3 +57,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/dataset_visualization/nmr_set.pdf filter=lfs diff=lfs merge=lfs -text
+data/examples/ProDcoNN.csv filter=lfs diff=lfs merge=lfs -text
+data/examples/Rosetta.csv filter=lfs diff=lfs merge=lfs -text
+data/examples/TIMED.csv filter=lfs diff=lfs merge=lfs -text
+data/examples/denseCPD.csv filter=lfs diff=lfs merge=lfs -text
+data/examples/evoEF2.csv filter=lfs diff=lfs merge=lfs -text

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Wells Wood Research Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/benchmark/__init__.py

@@ -0,0 +1 @@
+from .version import __version__

data/benchmark/config.py

@@ -0,0 +1,1036 @@
+acids = [
+    "A",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "K",
+    "L",
+    "M",
+    "N",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "V",
+    "W",
+    "Y",
+]
+
+UNCOMMON_RESIDUE_DICT = {
+    "DLY": "LYS",
+    "OTH": "THR",
+    "GHP": "GLY",
+    "YOF": "TYR",
+    "HS9": "HIS",
+    "HVA": "VAL",
+    "C5C": "CYS",
+    "TMD": "THR",
+    "NC1": "SER",
+    "CSR": "CYS",
+    "LYP": "LYS",
+    "PR4": "PRO",
+    "KPI": "LYS",
+    "02K": "ALA",
+    "4AW": "TRP",
+    "MLE": "LEU",
+    "NMM": "ARG",
+    "DNE": "LEU",
+    "NYS": "CYS",
+    "SEE": "SER",
+    "DSG": "ASN",
+    "ALA": "ALA",
+    "CSA": "CYS",
+    "SCH": "CYS",
+    "TQQ": "TRP",
+    "PTM": "TYR",
+    "XPR": "PRO",
+    "VLL": "UNK",
+    "B3Y": "TYR",
+    "PAQ": "TYR",
+    "FME": "MET",
+    "NAL": "ALA",
+    "TYI": "TYR",
+    "OXX": "ASP",
+    "CSS": "CYS",
+    "OCS": "CYS",
+    "193": "UNK",
+    "GLJ": "GLU",
+    "PM3": "PHE",
+    "DTR": "TRP",
+    "MEQ": "GLN",
+    "HSO": "HIS",
+    "TYW": "TYR",
+    "LED": "LEU",
+    "PHL": "PHE",
+    "TDD": "LEU",
+    "MEA": "PHE",
+    "FGA": "GLU",
+    "GGL": "GLU",
+    "PSH": "HIS",
+    "3CF": "PHE",
+    "MSE": "MET",
+    "2SO": "HIS",
+    "B3S": "SER",
+    "PSW": "SEC",
+    "C4R": "CYS",
+    "XCP": "UNK",
+    "LYF": "LYS",
+    "WFP": "PHE",
+    "A8E": "VAL",
+    "0AF": "TRP",
+    "PEC": "CYS",
+    "JJJ": "CYS",
+    "3TY": "UNK",
+    "SVY": "SER",
+    "DIL": "ILE",
+    "MHS": "HIS",
+    "MME": "MET",
+    "MMO": "ARG",
+    "B3A": "ALA",
+    "CHG": "UNK",
+    "PHI": "PHE",
+    "AR2": "ARG",
+    "MND": "ASN",
+    "BTR": "TRP",
+    "AEI": "ASP",
+    "TIH": "ALA",
+    "DDE": "HIS",
+    "S1H": "SER",
+    "DSE": "SER",
+    "AR4": "GLU",
+    "FDL": "LYS",
+    "PRJ": "PRO",
+    "CY3": "CYS",
+    "2TY": "TYR",
+    "AR7": "ARG",
+    "CTH": "THR",
+    "DTY": "TYR",
+    "SYS": "CYS",
+    "C1X": "LYS",
+    "SVV": "SER",
+    "ASN": "ASN",
+    "SNC": "CYS",
+    "AKZ": "ASP",
+    "OMY": "TYR",
+    "JJL": "CYS",
+    "XSN": "ASN",
+    "0UO": "TRP",
+    "TCQ": "TYR",
+    "OSE": "SER",
+    "NPH": "CYS",
+    "0A0": "ASP",
+    "1PA": "PHE",
+    "SIC": "CYS",
+    "TY8": "TYR",
+    "AYA": "ALA",
+    "ALN": "ALA",
+    "SXE": "SER",
+    "B3T": "UNK",
+    "BB9": "CYS",
+    "HL2": "LEU",
+    "0AR": "ARG",
+    "SVA": "SER",
+    "DBB": "THR",
+    "KPY": "LYS",
+    "DPP": "ALA",
+    "32S": "UNK",
+    "FGL": "GLY",
+    "N80": "PRO",
+    "IGL": "GLY",
+    "PF5": "PHE",
+    "OYL": "HIS",
+    "MNL": "LEU",
+    "PBF": "PHE",
+    "CEA": "CYS",
+    "OHI": "HIS",
+    "ESC": "MET",
+    "2JG": "SER",
+    "1X6": "SER",
+    "4BF": "TYR",
+    "MAA": "ALA",
+    "3X9": "CYS",
+    "BFD": "ASP",
+    "CZ2": "CYS",
+    "23P": "ALA",
+    "I4G": "GLY",
+    "CMT": "CYS",
+    "LVN": "VAL",
+    "OAS": "SER",
+    "TY2": "TYR",
+    "SCS": "CYS",
+    "PFX": "UNK",
+    "MF3": "UNK",
+    "OBS": "LYS",
+    "GL3": "GLY",
+    "0A9": "PHE",
+    "MVA": "VAL",
+    "B3Q": "UNK",
+    "DOA": "UNK",
+    "MP8": "PRO",
+    "CYR": "CYS",
+    "5PG": "GLY",
+    "ILY": "LYS",
+    "DNW": "ALA",
+    "BCX": "CYS",
+    "AZK": "LYS",
+    "AAR": "ARG",
+    "TRN": "TRP",
+    "NBQ": "TYR",
+    "RVX": "SER",
+    "PSA": "PHE",
+    "Z3E": "THR",
+    "OCY": "CYS",
+    "2ZC": "SER",
+    "N2C": "UNK",
+    "SBD": "SER",
+    "MSA": "GLY",
+    "SET": "SER",
+    "HS8": "HIS",
+    "SMF": "PHE",
+    "HYP": "PRO",
+    "PYX": "CYS",
+    "XPL": "PYL",
+    "DMK": "ASP",
+    "BIF": "PHE",
+    "M3L": "LYS",
+    "CYF": "CYS",
+    "O12": "UNK",
+    "SRZ": "SER",
+    "LAL": "ALA",
+    "2MR": "ARG",
+    "4PH": "PHE",
+    "2LT": "TYR",
+    "LPL": "UNK",
+    "3YM": "TYR",
+    "LRK": "LYS",
+    "FVA": "VAL",
+    "MED": "MET",
+    "ILM": "ILE",
+    "6CL": "LYS",
+    "CXM": "MET",
+    "DHV": "VAL",
+    "PR3": "CYS",
+    "HAR": "ARG",
+    "KWS": "GLY",
+    "SAR": "GLY",
+    "0LF": "PRO",
+    "45F": "PRO",
+    "12A": "A",
+    "CLG": "LYS",
+    "DHI": "HIS",
+    "PTR": "TYR",
+    "DMT": "UNK",
+    "OMT": "MET",
+    "TBG": "VAL",
+    "PLJ": "PRO",
+    "IAM": "ALA",
+    "DBY": "TYR",
+    "CPC": "UNK",
+    "GLZ": "GLY",
+    "4FW": "TRP",
+    "SLZ": "LYS",
+    "HIA": "HIS",
+    "FOE": "CYS",
+    "IYR": "TYR",
+    "KST": "LYS",
+    "B3M": "UNK",
+    "BB6": "CYS",
+    "CYW": "CYS",
+    "MPQ": "GLY",
+    "HHK": "LYS",
+    "HGL": "UNK",
+    "SE7": "ALA",
+    "ELY": "LYS",
+    "TRO": "TRP",
+    "DNP": "ALA",
+    "MK8": "LEU",
+    "200": "PHE",
+    "WVL": "VAL",
+    "LPD": "PRO",
+    "NCB": "ALA",
+    "DDZ": "ALA",
+    "MYK": "LYS",
+    "OLD": "HIS",
+    "DYS": "CYS",
+    "LET": "LYS",
+    "ESB": "TYR",
+    "HR7": "ARG",
+    "DI7": "TYR",
+    "QCS": "CYS",
+    "ASA": "ASP",
+    "CSX": "CYS",
+    "P3Q": "TYR",
+    "OHS": "ASP",
+    "SOY": "SER",
+    "EHP": "PHE",
+    "ZCL": "PHE",
+    "32T": "UNK",
+    "AHB": "ASN",
+    "TRX": "TRP",
+    "0AK": "ASP",
+    "TH5": "THR",
+    "GHG": "GLN",
+    "XW1": "ALA",
+    "23F": "PHE",
+    "1OP": "TYR",
+    "AGT": "CYS",
+    "PYA": "ALA",
+    "2MT": "PRO",
+    "4FB": "PRO",
+    "CSB": "CYS",
+    "TRQ": "TRP",
+    "MDO": "GLY",
+    "CAS": "CYS",
+    "TTQ": "TRP",
+    "T0I": "TYR",
+    "LLY": "LYS",
+    "GVL": "SER",
+    "BPE": "CYS",
+    "0TD": "ASP",
+    "TYY": "TYR",
+    "BH2": "ASP",
+    "D3P": "GLY",
+    "CY4": "CYS",
+    "CHP": "GLY",
+    "DFO": "UNK",
+    "NLB": "LEU",
+    "QPH": "PHE",
+    "DTH": "THR",
+    "LLO": "LYS",
+    "LYN": "LYS",
+    "DPN": "PHE",
+    "EFC": "CYS",
+    "FP9": "PRO",
+    "OMX": "TYR",
+    "AGQ": "TYR",
+    "PHD": "ASP",
+    "PR9": "PRO",
+    "B3L": "UNK",
+    "LYX": "LYS",
+    "IT1": "LYS",
+    "DBU": "THR",
+    "0A8": "CYS",
+    "TYX": "UNK",
+    "QMM": "GLN",
+    "CME": "CYS",
+    "ACB": "ASP",
+    "TRF": "TRP",
+    "HOX": "PHE",
+    "DA2": "ARG",
+    "DNS": "LYS",
+    "BIL": "UNK",
+    "SUN": "SER",
+    "TYJ": "TYR",
+    "3PX": "PRO",
+    "CLD": "SER",
+    "IPG": "GLY",
+    "CLH": "LYS",
+    "XCN": "CYS",
+    "CZZ": "CYS",
+    "THO": "UNK",
+    "CY1": "CYS",
+    "CYS": "CYS",
+    "PFF": "PHE",
+    "MLL": "LEU",
+    "PG1": "SER",
+    "BMT": "THR",
+    "CSZ": "CYS",
+    "DSN": "SER",
+    "NIY": "TYR",
+    "FH7": "LYS",
+    "CGV": "CYS",
+    "SVZ": "SER",
+    "ORQ": "ARG",
+    "DLS": "LYS",
+    "DVA": "VAL",
+    "BHD": "ASP",
+    "TPQ": "TYR",
+    "STY": "TYR",
+    "CSP": "CYS",
+    "31Q": "CYS",
+    "B3E": "GLU",
+    "LEF": "LEU",
+    "GLH": "GLU",
+    "LCK": "LYS",
+    "GME": "GLU",
+    "FHO": "LYS",
+    "MDH": "UNK",
+    "ECC": "GLN",
+    "34E": "VAL",
+    "ASB": "ASP",
+    "HCS": "UNK",
+    "KYN": "TRP",
+    "OIC": "UNK",
+    "VR0": "ARG",
+    "U2X": "TYR",
+    "PHE": "PHE",
+    "TYS": "TYR",
+    "SBG": "SER",
+    "A5N": "ASN",
+    "CYD": "CYS",
+    "4DP": "TRP",
+    "3AH": "HIS",
+    "FCL": "PHE",
+    "PRV": "GLY",
+    "CYQ": "CYS",
+    "MBQ": "TYR",
+    "DAS": "ASP",
+    "CS4": "CYS",
+    "B3K": "LYS",
+    "NLE": "LEU",
+    "143": "CYS",
+    "PR7": "PRO",
+    "DAH": "PHE",
+    "LE1": "VAL",
+    "TQZ": "CYS",
+    "LGY": "LYS",
+    "CML": "CYS",
+    "CSW": "CYS",
+    "N10": "SER",
+    "2RX": "SER",
+    "TOQ": "TRP",
+    "0AH": "SER",
+    "P2Q": "TYR",
+    "CYG": "CYS",
+    "DGL": "GLU",
+    "KOR": "MET",
+    "DAR": "ARG",
+    "2ML": "LEU",
+    "PTH": "TYR",
+    "CCS": "CYS",
+    "HMR": "ARG",
+    "33X": "ALA",
+    "UN2": "UNK",
+    "IML": "ILE",
+    "4CY": "MET",
+    "ZZJ": "ALA",
+    "DFI": "UNK",
+    "TIS": "SER",
+    "LLP": "LYS",
+    "MHU": "PHE",
+    "QPA": "CYS",
+    "175": "GLY",
+    "SAH": "CYS",
+    "IIL": "ILE",
+    "BCS": "CYS",
+    "R4K": "TRP",
+    "TYQ": "TYR",
+    "NCY": "UNK",
+    "FT6": "TRP",
+    "OBF": "UNK",
+    "0CS": "ALA",
+    "4HL": "TYR",
+    "TXY": "TYR",
+    "DOH": "ASP",
+    "CSE": "CYS",
+    "DAB": "ALA",
+    "GLK": "GLU",
+    "TYN": "TYR",
+    "LEI": "VAL",
+    "M0H": "CYS",
+    "CLB": "SER",
+    "MGG": "ARG",
+    "CGU": "GLU",
+    "UF0": "SER",
+    "SLL": "LYS",
+    "ML3": "LYS",
+    "HPH": "PHE",
+    "SME": "MET",
+    "ALC": "ALA",
+    "ASL": "ASP",
+    "CHS": "UNK",
+    "2TL": "THR",
+    "HT7": "TRP",
+    "SGB": "SER",
+    "OPR": "ARG",
+    "B3D": "ASP",
+    "FLT": "TYR",
+    "DGN": "GLN",
+    "4CF": "PHE",
+    "HLU": "LEU",
+    "FZN": "LYS",
+    "C6C": "CYS",
+    "HTI": "CYS",
+    "OMH": "SER",
+    "WLU": "LEU",
+    "23S": "UNK",
+    "U3X": "PHE",
+    "SEB": "SER",
+    "DBZ": "ALA",
+    "BB7": "CYS",
+    "2RA": "ALA",
+    "SCY": "CYS",
+    "6CW": "TRP",
+    "AHP": "ALA",
+    "ARO": "ARG",
+    "RE3": "TRP",
+    "1TQ": "TRP",
+    "VDL": "UNK",
+    "4IN": "TRP",
+    "GFT": "SER",
+    "CPI": "UNK",
+    "LSO": "LYS",
+    "CGA": "GLU",
+    "MLZ": "LYS",
+    "HTR": "TRP",
+    "00C": "CYS",
+    "FAK": "LYS",
+    "PRS": "PRO",
+    "ME0": "MET",
+    "SDP": "SER",
+    "HSL": "SER",
+    "C3Y": "CYS",
+    "823": "ASN",
+    "PHA": "PHE",
+    "LYZ": "LYS",
+    "HTN": "ASN",
+    "LP6": "LYS",
+    "ALV": "ALA",
+    "NVA": "VAL",
+    "CSD": "CYS",
+    "DMH": "ASN",
+    "PG9": "GLY",
+    "PCA": "GLU",
+    "KCX": "LYS",
+    "MDF": "TYR",
+    "TYB": "TYR",
+    "MHL": "LEU",
+    "GNC": "GLN",
+    "NLO": "LEU",
+    "MEN": "ASN",
+    "POM": "PRO",
+    "2HF": "HIS",
+    "CY0": "CYS",
+    "ZYK": "PRO",
+    "R1A": "CYS",
+    "CAF": "CYS",
+    "YCM": "CYS",
+    "ORN": "ALA",
+    "H5M": "PRO",
+    "MLY": "LYS",
+    "KYQ": "LYS",
+    "DPQ": "TYR",
+    "MIS": "SER",
+    "TPO": "THR",
+    "XX1": "LYS",
+    "SMC": "CYS",
+    "DHA": "SER",
+    "MGN": "GLN",
+    "FLA": "ALA",
+    "ILX": "ILE",
+    "QIL": "ILE",
+    "2KP": "LYS",
+    "CS1": "CYS",
+    "HNC": "CYS",
+    "PRK": "LYS",
+    "LYR": "LYS",
+    "DM0": "LYS",
+    "TSY": "CYS",
+    "NYB": "CYS",
+    "MHO": "MET",
+    "KFP": "LYS",
+    "SEN": "SER",
+    "999": "ASP",
+    "VLM": "UNK",
+    "CMH": "CYS",
+    "ONL": "UNK",
+    "M2L": "LYS",
+    "LME": "GLU",
+    "AIB": "ALA",
+    "CYJ": "LYS",
+    "CS3": "CYS",
+    "WPA": "PHE",
+    "MTY": "TYR",
+    "MIR": "SER",
+    "HZP": "PRO",
+    "LTA": "UNK",
+    "HIP": "HIS",
+    "PPN": "PHE",
+    "APK": "LYS",
+    "HPE": "PHE",
+    "SVX": "SER",
+    "JJK": "CYS",
+    "03Y": "CYS",
+    "D4P": "UNK",
+    "1AC": "ALA",
+    "B3X": "ASN",
+    "0FL": "ALA",
+    "2KK": "LYS",
+    "LMQ": "GLN",
+    "RE0": "TRP",
+    "MSO": "MET",
+    "ZYJ": "PRO",
+    "GMA": "GLU",
+    "DPR": "PRO",
+    "1TY": "TYR",
+    "TOX": "TRP",
+    "DPL": "PRO",
+    "M2S": "MET",
+    "4HT": "TRP",
+    "BUC": "CYS",
+    "C1S": "CYS",
+    "TA4": "UNK",
+    "CSO": "CYS",
+    "5CW": "TRP",
+    "TRW": "TRP",
+    "DCY": "CYS",
+    "DAL": "ALA",
+    "0QL": "CYS",
+    "THC": "THR",
+    "FGP": "SER",
+    "MCS": "CYS",
+    "AZH": "ALA",
+    "HIQ": "HIS",
+    "ABA": "ASN",
+    "TH6": "THR",
+    "FHL": "LYS",
+    "ZAL": "ALA",
+    "ICY": "CYS",
+    "IZO": "MET",
+    "F2F": "PHE",
+    "VAI": "VAL",
+    "TY5": "TYR",
+    "07O": "CYS",
+    "AA4": "ALA",
+    "RGL": "ARG",
+    "SAC": "SER",
+    "PXU": "PRO",
+    "NFA": "PHE",
+    "LA2": "LYS",
+    "0BN": "PHE",
+    "LYK": "LYS",
+    "FTY": "TYR",
+    "NZH": "HIS",
+    "CSJ": "CYS",
+    "30V": "CYS",
+    "DLE": "LEU",
+    "TLY": "LYS",
+    "L3O": "LEU",
+    "LDH": "LYS",
+    "NEP": "HIS",
+    "ALY": "LYS",
+    "GPL": "LYS",
+    "01W": "UNK",
+    "WRP": "TRP",
+    "MCL": "LYS",
+    "2AS": "UNK",
+    "CSU": "CYS",
+    "SOC": "CYS",
+    "HRG": "ARG",
+    "NMC": "GLY",
+    "TYO": "TYR",
+    "LHC": "UNK",
+    "D11": "THR",
+    "I2M": "ILE",
+    "TTS": "TYR",
+    "FC0": "PHE",
+    "HIC": "HIS",
+    "YPZ": "TYR",
+    "5CS": "CYS",
+    "SEP": "SER",
+    "BBC": "CYS",
+    "3MY": "TYR",
+    "HQA": "ALA",
+    "11Q": "PRO",
+    "AGM": "ARG",
+    "BG1": "SER",
+    "IAS": "ASP",
+    "SBL": "SER",
+    "56A": "HIS",
+    "FTR": "TRP",
+    "DIV": "VAL",
+    "ALO": "THR",
+    "BTK": "LYS",
+    "M3R": "ARG",
+}
+
+blosum62 = {
+    ("W", "F"): 1,
+    ("L", "R"): -2,
+    ("S", "P"): -1,
+    ("V", "T"): 0,
+    ("Q", "Q"): 5,
+    ("N", "A"): -2,
+    ("Z", "Y"): -2,
+    ("W", "R"): -3,
+    ("Q", "A"): -1,
+    ("S", "D"): 0,
+    ("H", "H"): 8,
+    ("S", "H"): -1,
+    ("H", "D"): -1,
+    ("L", "N"): -3,
+    ("W", "A"): -3,
+    ("Y", "M"): -1,
+    ("G", "R"): -2,
+    ("Y", "I"): -1,
+    ("Y", "E"): -2,
+    ("B", "Y"): -3,
+    ("Y", "A"): -2,
+    ("V", "D"): -3,
+    ("B", "S"): 0,
+    ("Y", "Y"): 7,
+    ("G", "N"): 0,
+    ("E", "C"): -4,
+    ("Y", "Q"): -1,
+    ("Z", "Z"): 4,
+    ("V", "A"): 0,
+    ("C", "C"): 9,
+    ("M", "R"): -1,
+    ("V", "E"): -2,
+    ("T", "N"): 0,
+    ("P", "P"): 7,
+    ("V", "I"): 3,
+    ("V", "S"): -2,
+    ("Z", "P"): -1,
+    ("V", "M"): 1,
+    ("T", "F"): -2,
+    ("V", "Q"): -2,
+    ("K", "K"): 5,
+    ("P", "D"): -1,
+    ("I", "H"): -3,
+    ("I", "D"): -3,
+    ("T", "R"): -1,
+    ("P", "L"): -3,
+    ("K", "G"): -2,
+    ("M", "N"): -2,
+    ("P", "H"): -2,
+    ("F", "Q"): -3,
+    ("Z", "G"): -2,
+    ("X", "L"): -1,
+    ("T", "M"): -1,
+    ("Z", "C"): -3,
+    ("X", "H"): -1,
+    ("D", "R"): -2,
+    ("B", "W"): -4,
+    ("X", "D"): -1,
+    ("Z", "K"): 1,
+    ("F", "A"): -2,
+    ("Z", "W"): -3,
+    ("F", "E"): -3,
+    ("D", "N"): 1,
+    ("B", "K"): 0,
+    ("X", "X"): -1,
+    ("F", "I"): 0,
+    ("B", "G"): -1,
+    ("X", "T"): 0,
+    ("F", "M"): 0,
+    ("B", "C"): -3,
+    ("Z", "I"): -3,
+    ("Z", "V"): -2,
+    ("S", "S"): 4,
+    ("L", "Q"): -2,
+    ("W", "E"): -3,
+    ("Q", "R"): 1,
+    ("N", "N"): 6,
+    ("W", "M"): -1,
+    ("Q", "C"): -3,
+    ("W", "I"): -3,
+    ("S", "C"): -1,
+    ("L", "A"): -1,
+    ("S", "G"): 0,
+    ("L", "E"): -3,
+    ("W", "Q"): -2,
+    ("H", "G"): -2,
+    ("S", "K"): 0,
+    ("Q", "N"): 0,
+    ("N", "R"): 0,
+    ("H", "C"): -3,
+    ("Y", "N"): -2,
+    ("G", "Q"): -2,
+    ("Y", "F"): 3,
+    ("C", "A"): 0,
+    ("V", "L"): 1,
+    ("G", "E"): -2,
+    ("G", "A"): 0,
+    ("K", "R"): 2,
+    ("E", "D"): 2,
+    ("Y", "R"): -2,
+    ("M", "Q"): 0,
+    ("T", "I"): -1,
+    ("C", "D"): -3,
+    ("V", "F"): -1,
+    ("T", "A"): 0,
+    ("T", "P"): -1,
+    ("B", "P"): -2,
+    ("T", "E"): -1,
+    ("V", "N"): -3,
+    ("P", "G"): -2,
+    ("M", "A"): -1,
+    ("K", "H"): -1,
+    ("V", "R"): -3,
+    ("P", "C"): -3,
+    ("M", "E"): -2,
+    ("K", "L"): -2,
+    ("V", "V"): 4,
+    ("M", "I"): 1,
+    ("T", "Q"): -1,
+    ("I", "G"): -4,
+    ("P", "K"): -1,
+    ("M", "M"): 5,
+    ("K", "D"): -1,
+    ("I", "C"): -1,
+    ("Z", "D"): 1,
+    ("F", "R"): -3,
+    ("X", "K"): -1,
+    ("Q", "D"): 0,
+    ("X", "G"): -1,
+    ("Z", "L"): -3,
+    ("X", "C"): -2,
+    ("Z", "H"): 0,
+    ("B", "L"): -4,
+    ("B", "H"): 0,
+    ("F", "F"): 6,
+    ("X", "W"): -2,
+    ("B", "D"): 4,
+    ("D", "A"): -2,
+    ("S", "L"): -2,
+    ("X", "S"): 0,
+    ("F", "N"): -3,
+    ("S", "R"): -1,
+    ("W", "D"): -4,
+    ("V", "Y"): -1,
+    ("W", "L"): -2,
+    ("H", "R"): 0,
+    ("W", "H"): -2,
+    ("H", "N"): 1,
+    ("W", "T"): -2,
+    ("T", "T"): 5,
+    ("S", "F"): -2,
+    ("W", "P"): -4,
+    ("L", "D"): -4,
+    ("B", "I"): -3,
+    ("L", "H"): -3,
+    ("S", "N"): 1,
+    ("B", "T"): -1,
+    ("L", "L"): 4,
+    ("Y", "K"): -2,
+    ("E", "Q"): 2,
+    ("Y", "G"): -3,
+    ("Z", "S"): 0,
+    ("Y", "C"): -2,
+    ("G", "D"): -1,
+    ("B", "V"): -3,
+    ("E", "A"): -1,
+    ("Y", "W"): 2,
+    ("E", "E"): 5,
+    ("Y", "S"): -2,
+    ("C", "N"): -3,
+    ("V", "C"): -1,
+    ("T", "H"): -2,
+    ("P", "R"): -2,
+    ("V", "G"): -3,
+    ("T", "L"): -1,
+    ("V", "K"): -2,
+    ("K", "Q"): 1,
+    ("R", "A"): -1,
+    ("I", "R"): -3,
+    ("T", "D"): -1,
+    ("P", "F"): -4,
+    ("I", "N"): -3,
+    ("K", "I"): -3,
+    ("M", "D"): -3,
+    ("V", "W"): -3,
+    ("W", "W"): 11,
+    ("M", "H"): -2,
+    ("P", "N"): -2,
+    ("K", "A"): -1,
+    ("M", "L"): 2,
+    ("K", "E"): 1,
+    ("Z", "E"): 4,
+    ("X", "N"): -1,
+    ("Z", "A"): -1,
+    ("Z", "M"): -1,
+    ("X", "F"): -1,
+    ("K", "C"): -3,
+    ("B", "Q"): 0,
+    ("X", "B"): -1,
+    ("B", "M"): -3,
+    ("F", "C"): -2,
+    ("Z", "Q"): 3,
+    ("X", "Z"): -1,
+    ("F", "G"): -3,
+    ("B", "E"): 1,
+    ("X", "V"): -1,
+    ("F", "K"): -3,
+    ("B", "A"): -2,
+    ("X", "R"): -1,
+    ("D", "D"): 6,
+    ("W", "G"): -2,
+    ("Z", "F"): -3,
+    ("S", "Q"): 0,
+    ("W", "C"): -2,
+    ("W", "K"): -3,
+    ("H", "Q"): 0,
+    ("L", "C"): -1,
+    ("W", "N"): -4,
+    ("S", "A"): 1,
+    ("L", "G"): -4,
+    ("W", "S"): -3,
+    ("S", "E"): 0,
+    ("H", "E"): 0,
+    ("S", "I"): -2,
+    ("H", "A"): -2,
+    ("S", "M"): -1,
+    ("Y", "L"): -1,
+    ("Y", "H"): 2,
+    ("Y", "D"): -3,
+    ("E", "R"): 0,
+    ("X", "P"): -2,
+    ("G", "G"): 6,
+    ("G", "C"): -3,
+    ("E", "N"): 0,
+    ("Y", "T"): -2,
+    ("Y", "P"): -3,
+    ("T", "K"): -1,
+    ("A", "A"): 4,
+    ("P", "Q"): -1,
+    ("T", "C"): -1,
+    ("V", "H"): -3,
+    ("T", "G"): -2,
+    ("I", "Q"): -3,
+    ("Z", "T"): -1,
+    ("C", "R"): -3,
+    ("V", "P"): -2,
+    ("P", "E"): -1,
+    ("M", "C"): -1,
+    ("K", "N"): 0,
+    ("I", "I"): 4,
+    ("P", "A"): -1,
+    ("M", "G"): -3,
+    ("T", "S"): 1,
+    ("I", "E"): -3,
+    ("P", "M"): -2,
+    ("M", "K"): -1,
+    ("I", "A"): -1,
+    ("P", "I"): -3,
+    ("R", "R"): 5,
+    ("X", "M"): -1,
+    ("L", "I"): 2,
+    ("X", "I"): -1,
+    ("Z", "B"): 1,
+    ("X", "E"): -1,
+    ("Z", "N"): 0,
+    ("X", "A"): 0,
+    ("B", "R"): -1,
+    ("B", "N"): 3,
+    ("F", "D"): -3,
+    ("X", "Y"): -1,
+    ("Z", "R"): 0,
+    ("F", "H"): -1,
+    ("B", "F"): -3,
+    ("F", "L"): 0,
+    ("X", "Q"): -1,
+    ("B", "B"): 4,
+}
+
+classes = {
+    1: "Mainly Alpha",
+    2: "Mainly Beta",
+    3: "Alpha Beta",
+    4: "Few Structures/Special",
+}
+
+architectures = {
+    "1.10": "Orthogonal Bundle",
+    "1.20": "Up-down Bundle",
+    "1.25": "Alpha Horseshoe",
+    "1.40": "Alpha solenoid",
+    "1.50": "Alpha/alpha barrel",
+    "2.10": "Ribbon",
+    "2.20": "Single Sheet",
+    "2.30": "Roll",
+    "2.40": "Beta Barrel",
+    "2.50": "Clam",
+    "2.60": "Sandwich",
+    "2.70": "Distorted Sandwich",
+    "2.80": "Trefoil",
+    "2.90": "Orthogonal Prism",
+    "2.100": "Aligned Prism",
+    "2.102": "3-layer Sandwich",
+    "2.105": "3 Propeller",
+    "2.110": "4 Propeller",
+    "2.115": "5 Propeller",
+    "2.120": "6 Propeller",
+    "2.130": "7 Propeller",
+    "2.140": "8 Propeller",
+    "2.150": "2 Solenoid",
+    "2.160": "3 Solenoid",
+    "2.170": "Beta Complex",
+    "2.180": "Shell",
+    "3.10": "Roll",
+    "3.15": "Super Roll",
+    "3.20": "Alpha-Beta Barrel",
+    "3.30": "2-Layer Sandwich",
+    "3.40": "3-Layer(aba) Sandwich",
+    "3.50": "3-Layer(bba) Sandwich",
+    "3.55": "3-Layer(bab) Sandwich",
+    "3.60": "4-Layer Sandwich",
+    "3.65": "Alpha-beta prism",
+    "3.70": "Box",
+    "3.75": "5-stranded Propeller",
+    "3.80": "Alpha-Beta Horseshoe",
+    "3.90": "Alpha-Beta Complex",
+    "3.100": "Ribosomal Protein L15; Chain: K; domain 2",
+    "4.10": "Irregular",
+    "6.10": "Helix non-globular",
+    "6.20": "Other non-globular",
+}
+
+# move into .txt file, no need for a special function for ts50.
+ts50 = [
+    "1AHSA",
+    "1BVYF",
+    "1PDOA",
+    "2VA0A",
+    "3IEYB",
+    "2XR6A",
+    "3II2A",
+    "1OR4A",
+    "2QDLA",
+    "3NZMA",
+    "3VJZA",
+    "1ETEA",
+    "2A2LA",
+    "2FVVA",
+    "3L4RA",
+    "1LPBA",
+    "3NNGA",
+    "2CVIA",
+    "3GKNA",
+    "2J49A",
+    "3FHKA",
+    "3PIVA",
+    "3LQCA",
+    "3GFSA",
+    "3E8MA",
+    "1DX5I",
+    "3NY7A",
+    "3K7PA",
+    "2CAYA",
+    "1I8NA",
+    "1V7MV",
+    "1H4AX",
+    "3T5GB",
+    "3Q4OA",
+    "3A4RA",
+    "2I39A",
+    "3AQGA",
+    "3EJFA",
+    "3NBKA",
+    "4GCNA",
+    "2XDGA",
+    "3GWIA",
+    "3HKLA",
+    "3SO6A",
+    "3ON9A",
+    "4DKCA",
+    "2GU3A",
+    "2XCJA",
+    "1Y1LA",
+    "1MR1C",
+]

data/benchmark/get_cath.py

@@ -0,0 +1,1029 @@
+"""Functions for creating and scoring CATH datasets"""
+
+import numpy as np
+import pandas as pd
+import ampal
+import gzip
+from pathlib import Path
+from sklearn import metrics
+from benchmark import config
+import string
+from subprocess import CalledProcessError
+import re
+from scipy.stats import entropy
+from benchmark import visualization
+from typing import Tuple, List, Iterable
+import warnings
+from sklearn.preprocessing import LabelBinarizer
+import wget
+import click
+
+def download_data(out_dir: Path) -> None:
+    """Download CATH file.
+    
+    Parameters
+    ----------
+    out_dir: Path:
+        Directory where to store the file."""
+    if click.confirm(
+            f"CATH file does not exist. It will be downloaded to {out_dir.resolve()}. Continue? "
+        ):
+         wget.download('ftp://orengoftp.biochem.ucl.ac.uk/cath/releases/latest-release/cath-classification-data/cath-domain-description-file.txt', out=str(out_dir))
+    else:
+        exit()
+   
+def read_data(CATH_file: str) -> pd.DataFrame:
+    """If CATH .csv exists, loads the DataFrame. If CATH .txt exists, makes DataFrame and saves it. If CATH .txt file doesn't exist, downloads it.
+
+    Parameters
+    ----------
+    CATH_file: str
+        CATH .txt file name.
+
+    Returns
+    -------
+    df:pd.DataFrame
+        DataFrame containing CATH and PDB codes."""
+    path = Path(CATH_file)
+    #download if doesn't exist.
+    if not path.exists():
+        download_data(path.parent)
+    # load .csv if exists, faster than reading .txt
+    if path.with_suffix(".csv").exists():
+        df = pd.read_csv(path.with_suffix(".csv"), index_col=0)
+        # start, stop needs to be str
+        df["start"] = df["start"].apply(str)
+        df["stop"] = df["stop"].apply(str)
+        return df
+
+    else:
+        cath_info = []
+        temp = []
+        start_stop = []
+        with open(path) as file:
+            for line in file:
+                if line[:6] == "DOMAIN":
+                    # PDB
+                    temp.append(line[10:14])
+                    # chain
+                    temp.append(line[14])
+                if line[:6] == "CATHCO":
+                    # class, architecture, topology, homologous superfamily
+                    cath = [int(i) for i in line[10:].strip("\n").split(".")]
+                    temp = temp + cath
+                if line[:6] == "SRANGE":
+                    j = line.split()
+                    # start and stop resi, can be multiple for the same chain
+                    # must be str to deal with insertions (1A,1B) later.
+                    start_stop.append([str(j[1][6:]), str(j[2][5:])])
+                if line[:2] == "//":
+                    # keep fragments from the same chain as separate entries
+                    for fragment in start_stop:
+                        cath_info.append(temp + fragment)
+                    start_stop = []
+                    temp = []
+        df = pd.DataFrame(
+            cath_info,
+            columns=[
+                "PDB",
+                "chain",
+                "class",
+                "architecture",
+                "topology",
+                "hsf",
+                "start",
+                "stop",
+            ],
+        )
+        df.to_csv(path.with_suffix(".csv"))
+        return df
+
+
+def tag_dssp_data(assembly: ampal.Assembly) -> None:
+    """Same as ampal.dssp.tag_dssp_data(), but fixed a bug with insertions. Tags each residue in ampal.Assembly with secondary structure. Works in place.
+
+    Parameters
+    ----------
+    assembly: ampal.Assembly
+        Protein assembly."""
+
+    dssp_out = ampal.dssp.run_dssp(assembly.pdb, path=False)
+    dssp_data = ampal.dssp.extract_all_ss_dssp(dssp_out, path=False)
+    for i, record in enumerate(dssp_data):
+        rnum, sstype, chid, _, phi, psi, sacc = record
+        # deal with insertions
+        if len(chid) > 1:
+            for i, res in enumerate(assembly[chid[1]]):
+                if res.insertion_code == chid[0] and assembly[chid[1]][i].tags == {}:
+                    assembly[chid[1]][i].tags["dssp_data"] = {
+                        "ss_definition": sstype,
+                        "solvent_accessibility": sacc,
+                        "phi": phi,
+                        "psi": psi,
+                    }
+                    break
+
+        else:
+            assembly[chid][str(rnum)].tags["dssp_data"] = {
+                "ss_definition": sstype,
+                "solvent_accessibility": sacc,
+                "phi": phi,
+                "psi": psi,
+            }
+
+
+def get_sequence(
+    series: pd.Series, path_to_pdb: Path
+) -> Tuple[str, str, int, int, List[int]]:
+    """Gets a sequence of from PDB file, CATH fragment indexes and secondary structure labels.
+
+    Parameters
+    ----------
+    series: pd.Series
+        Series containing one CATH instance.
+    path_to_assemblies:Path
+        Path to directory with biologcial assemblies.
+
+    Returns
+    -------
+    sequence: str
+        True sequence.
+    dssp: str
+        dssp codes.
+    start: int
+        CATH fragment start residue number, same as in PDB. NOT EQUAL TO SEQUENCE INDEX.
+    stop:int
+        CATH fragment stop residue number, same as in PDB. NOT EQUAL TO SEQUENCE INDEX.
+    uncommon_index:list
+        List with residue number of uncommon amino acids.
+    """
+
+    path = path_to_pdb / series.PDB[1:3] / f"pdb{series.PDB}.ent.gz"
+
+    if path.exists():
+        with gzip.open(path, "rb") as protein:
+            assembly = ampal.load_pdb(protein.read().decode(), path=False)
+            # convert pdb res id into sequence index,
+            # some files have discontinuous residue ids so ampal.get_slice_from_res_id() does not work
+            start = 0
+            stop = 0
+            # if nmr structure, get 1st model
+            if isinstance(assembly, ampal.AmpalContainer):
+                assembly = assembly[0]
+            # run dssp
+            try:
+                tag_dssp_data(assembly)
+            except CalledProcessError:
+                raise CalledProcessError(f"dssp failed on {series.PDB}.pdb.")
+            # some biological assemblies are broken
+            try:
+                chain = assembly[series.chain]
+            except KeyError:
+                raise KeyError(f"{series.PDB}.pdb is missing chain {series.chain}.")
+
+            # compatibility with evoef and leo's model, store non-canonical residue index in a separate column and include regular amino acid in the sequence
+            sequence = ""
+            uncommon_index = []
+            dssp = ""
+            for i, residue in enumerate(chain):
+                # add dssp data, assume random structure if dssp did not return anything for this residue
+                try:
+                    dssp += residue.tags["dssp_data"]["ss_definition"]
+                except KeyError:
+                    dssp += " "
+                # deal with uncommon residues
+                one_letter_code = ampal.amino_acids.get_aa_letter(residue.mol_code)
+                if one_letter_code == "X":
+                    try:
+                        uncommon_index.append(i)
+                        sequence += ampal.amino_acids.get_aa_letter(
+                            config.UNCOMMON_RESIDUE_DICT[residue.mol_code]
+                        )
+                    except KeyError:
+                        raise ValueError(
+                            f"{series.PDB}.pdb has unrecognized amino acid {residue.mol_code}."
+                        )
+                else:
+                    sequence += one_letter_code
+
+                # deal with insertions
+                if series.start[-1].isalpha():
+                    if (residue.id + residue.insertion_code) == series.start:
+                        start = i
+                else:
+                    if residue.id == series.start:
+                        start = i
+                if series.stop[-1].isalpha():
+                    if (residue.id + residue.insertion_code) == series.stop:
+                        stop = i
+                else:
+                    if residue.id == series.stop:
+                        stop = i
+        if uncommon_index==[]:
+            uncommon_index=np.NaN
+        return sequence, dssp, start, stop, uncommon_index
+    else:
+        raise FileNotFoundError(
+            f"{series.PDB}.pdb is missing, download it or remove it from your dataset."
+        )
+
+
+def get_pdbs(
+    df: pd.DataFrame, cls: int, arch: int = 0, topo: int = 0, homologous_sf: int = 0
+) -> pd.DataFrame:
+    """Gets PDBs based on CATH code, at least class has to be specified.
+
+    Parameters
+    ----------
+        df: pd.DataFrame
+            DataFrame containing CATH dataset.
+        cls: int
+            CATH class
+        arch: int = 0
+            CATH architecture
+        topo: int = 0
+            CATH topology
+        homologous_sf: int = 0
+            CATH homologous superfamily
+
+    Returns
+    -------
+    df:pd.DataFrame
+        DataFrame containing PDBs with specified CATH code."""
+
+    if homologous_sf != 0:
+        return df.loc[
+            (df["class"] == cls)
+            & (df["topology"] == topo)
+            & (df["architecture"] == arch)
+            & (df["hsf"] == homologous_sf)
+        ].copy()
+    elif topo != 0:
+        return df.loc[
+            (df["class"] == cls)
+            & (df["topology"] == topo)
+            & (df["architecture"] == arch)
+        ].copy()
+    elif arch != 0:
+        return df.loc[(df["class"] == cls) & (df["architecture"] == arch)].copy()
+    else:
+        return df.loc[(df["class"] == cls)].copy()
+
+
+def get_resolution(df: pd.DataFrame, path_to_pdb: Path) -> List[float]:
+    """Gets resolution of each structure in DataFrame
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        DataFrame with CATH fragment info.
+    path_to_pdb: Path
+        Path to the directory with PDB files.
+
+    Returns
+    -------
+    res: list
+        List with resolutions."""
+
+    res = []
+    for i, protein in df.iterrows():
+        path = path_to_pdb / protein.PDB[1:3] / f"pdb{protein.PDB}.ent.gz"
+
+        if path.exists():
+            with gzip.open(path, "rb") as pdb:
+                pdb_text = pdb.read().decode()
+            item = re.findall("REMARK   2 RESOLUTION.*$", pdb_text, re.MULTILINE)
+            
+            if item[0].split()[3]!='NOT':
+                res.append(float(item[0].split()[3]))
+            #nmr structures have no resolution
+            else:
+                res.append(np.NaN)
+        else:
+            res.append(np.NaN)
+    return res
+
+
+def append_sequence(
+    df: pd.DataFrame, path_to_pdb: Path
+) -> pd.DataFrame:
+    """Get sequences for all entries in the dataframe, changes start and stop from PDB resid to index number,adds resolution of each chain.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        CATH dataframe.
+    path_to_pdb: Path
+        Path to the directory with PDB files.
+
+
+    Returns
+    -------
+    working_copy:pd.DataFrame
+        DataFrame with appended sequences,dssp data, start/stop numbers, uncommon index list and resolution data."""
+
+    # make copy to avoid changing original df.
+    working_copy = df.copy()
+    sequence, dssp, start, stop, uncommon_index = zip(
+        *[get_sequence(x, path_to_pdb) for i, x in df.iterrows()]
+    )
+    working_copy.loc[:, "sequence"] = sequence
+    working_copy.loc[:, "dssp"] = dssp
+    working_copy.loc[:, "start"] = start
+    working_copy.loc[:, "stop"] = stop
+    working_copy.loc[:, "uncommon_index"]=uncommon_index
+    working_copy.loc[:, "resolution"] = get_resolution(working_copy, path_to_pdb)
+
+    return working_copy
+
+
+def filter_with_user_list(
+    df: pd.DataFrame, path: Path, ispisces: bool = False
+) -> pd.DataFrame:
+    """Selects PDB chains specified in .txt file. Multiple CATH entries for the same protein are removed to leave only one example.
+    Parameters
+    ----------
+    df: pd.DataFrame
+        CATH info containing dataframe
+    path: Path
+        Path to dataset .txt file
+    ispisces:bool = False
+        Reads pisces formating if True, otherwise pdb+chain, e.g., 1a2bA\n.
+
+    Returns
+    -------
+    DataFrame with selected chains."""
+
+    path = Path(path)
+    with open(path) as file:
+        if ispisces:
+            filtr = [x.split()[0] for x in file.readlines()[1:]]
+        else:
+            filtr = [x.upper().strip("\n") for x in file.readlines()]
+    frame_copy = df.copy()
+    frame_copy["PDB+chain"] = df.PDB + df.chain
+    # must be upper letters for string comparison
+    frame_copy["PDB+chain"] = frame_copy["PDB+chain"].str.upper()
+    return df.loc[frame_copy["PDB+chain"].isin(filtr)].drop_duplicates(
+        subset=["PDB", "chain"]
+    )
+
+
+def filter_with_resolution(
+    df: pd.DataFrame, minimum: float, maximum: float
+) -> pd.DataFrame:
+    """Gets DataFrame slice with chain resolution between min and max.
+
+    Parameters:
+    -----------
+    df: pd.DataFrame
+        CATH DataFrame.
+    minimum:float
+    maximum:float
+
+    Returns
+    -------
+    DataFrame with chains."""
+
+    return df[(df["resolution"] >= minimum) & (df["resolution"] < maximum)]
+
+
+def lookup_blosum62(res_true: str, res_prediction: str) -> int:
+    """Returns score from the matrix.
+
+    Parameters
+    ----------
+    res_true: str
+        First residue code.
+    res_prediction: str
+        Second residue code.
+
+    Returns
+    --------
+    Score from the matrix."""
+
+    if (res_true, res_prediction) in config.blosum62.keys():
+        return config.blosum62[res_true, res_prediction]
+    else:
+        return config.blosum62[res_prediction, res_true]
+
+def load_prediction_matrix(
+    df: pd.DataFrame, path_to_dataset: Path, path_to_probabilities: Path
+) -> dict:
+    """Loads predicted probabilities from .csv file to dictionary, drops entries for which sequence prediction fails.
+    Parameters
+    ----------
+    df: pd.DataFrame
+        CATH dataframe.
+    path_to_dataset: Path
+        Path to prediction dataset labels.
+    path_to_probabilities:Path
+        Path to .csv file with probabilities.
+
+    Returns
+    -------
+    empty_dict:dict
+        Dictionary with predicted sequences, key is PDB+chain."""
+
+    path_to_dataset = Path(path_to_dataset)
+    path_to_probabilities = Path(path_to_probabilities)
+    counter=0
+    with open(path_to_dataset) as file:
+        labels = [x.strip('\n').split() for x in file.readlines()[3:]]
+    predictions = pd.read_csv(path_to_probabilities, header=None).values
+    empty_dict = {k: [] for k in df.PDB.values + df.chain.values}
+    for chain in labels:
+        if chain[0] in empty_dict:
+            empty_dict[chain[0]]=predictions[counter:counter+int(chain[1])]
+        counter+=int(chain[1])
+    # drop keys with missing values
+    filtered_empty_dict = {
+         k: v for k, v in empty_dict.items() if len(v) != 0
+    }
+    # warn about missing predictions
+    missing_structures = [x for x in empty_dict if x not in filtered_empty_dict]
+    if len(missing_structures) > 0:
+        warnings.warn(f"{path_to_probabilities.name}: {*missing_structures,} predictions are missing.")
+    return filtered_empty_dict
+
+
+def most_likely_sequence(probability_matrix: np.array) -> str:
+    """Makes protein sequence from probability matrix.
+
+    Parameters
+    ----------
+    probability_matrix: np.array
+        Array in shape n,20 with probabilities for each amino acid.
+
+    Returns
+    -------
+    String with the sequence"""
+
+    if len(probability_matrix) > 0:
+        most_likely_seq = [
+            config.acids[x] for x in np.argmax(probability_matrix, axis=1)
+        ]
+        return "".join(most_likely_seq)
+    else:
+        return ""
+
+
+def format_sequence(
+    df: pd.DataFrame,
+    predictions: dict,
+    by_fragment: bool = True,
+    ignore_uncommon:bool=False,
+) -> Tuple[np.array, np.array, np.array, List[List], List[List]]:
+    """
+    Concatenates and formats all sequences in the DataFrame for metrics calculations.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        DataFrame with CATH fragment info. The frame must have predicted sequence, true sequence and start/stop index of CATH fragment.
+    predictions: dict
+        Dictionary with loaded predictions.
+    by_fragment: bool
+        If true scores only CATH fragments, if False, scores entire chain.
+    ignore_uncommon=True
+        If True, ignores uncommon residues in accuracy calculations.
+    score_sequence=False
+        True if dictionary contains sequences, False if probability matrices(matrix shape n,20).
+
+    Returns
+    -------
+    sequece:np.array
+        Array with protein sequence.
+    prediction:np.array
+        Array of predicted protein residues or probability matrix, shape n or n,20.
+    dssp: np.array
+        Array with dssp data.
+    true_secondary:List[List[Union(chr,np.array)]]
+        List with true sequences split by secondary structure type. Entries can be character lists or np.arrays with probability matrices. Format:[helices,sheets,loops,random].
+    predicted_secondary:List[List[Union[chr,np.array]]
+        List with predicted sequences split by secondary structure type. Entries can be character lists or np.arrays with probability matrices. Format:[helices,sheets,loops,random].
+    """
+    sequence = ""
+    dssp = ""
+    # Store failed structures
+    failed = []
+    prediction = np.empty([0, 20])
+    for i, protein in df.iterrows():
+        if protein.PDB + protein.chain in predictions:
+            start = protein.start
+            stop = protein.stop
+            predicted_sequence = predictions[protein.PDB + protein.chain]
+            # remove uncommon acids
+            if ignore_uncommon and isinstance(protein.uncommon_index,list):
+                protein_sequence = "".join(
+                    [
+                        x
+                        for i, x in enumerate(protein.sequence)
+                        if i not in protein.uncommon_index
+                    ]
+                )
+                protein_dssp = "".join(
+                    [
+                        x
+                        for i, x in enumerate(protein.dssp)
+                        if i not in protein.uncommon_index
+                    ]
+                )
+                # update start and stop indexes
+                start = start - (np.array(protein.uncommon_index) <= start).sum()
+                stop = stop - (np.array(protein.uncommon_index) <= stop).sum()
+            else:
+                protein_sequence = protein.sequence
+                protein_dssp = protein.dssp
+
+            # check length
+            if len(protein_sequence) != len(predicted_sequence):
+                # prediction is multimer-this is for compatibility with older EvoEF2 runs. Fixed now.
+                if len(predicted_sequence) % len(protein_sequence) == 0:
+                    predicted_sequence = predicted_sequence[0 : len(protein_sequence)]
+                else:
+                    failed.append(protein.PDB + protein.chain)
+                    continue
+
+            if by_fragment:
+                protein_sequence = protein_sequence[start : stop + 1]
+                protein_dssp = protein_dssp[start : stop + 1]
+                predicted_sequence = predicted_sequence[start : stop + 1]
+
+            if len(protein_sequence) == len(predicted_sequence) and len(
+                protein_sequence
+            ) == len(protein_dssp):
+                sequence += protein_sequence
+                dssp += protein_dssp
+                prediction = np.concatenate(
+                    [prediction, predicted_sequence], axis=0
+                )
+            else:
+                failed.append(protein.PDB + protein.chain)
+    # Get all failed structures.
+    if len(failed) > 0:
+        raise ValueError(
+            f"Sequence, predicted sequence and dssp length do not match for these structures: {*failed,}"
+        )
+
+    sequence = np.array(list(sequence))
+    dssp = np.array(list(dssp))
+    # format secondary structures
+    true_secondary = [[], [], [], []]
+    prediction_secondary = [[], [], [], []]
+    # combine secondary structures for simplicity.
+    assert len(dssp)==len(sequence) and len(dssp)==len(prediction), 'format_sequence failed; dssp, sequence and prediction have different lengths.'
+    for structure, truth, pred in zip(dssp, sequence, prediction):
+        if structure == "H" or structure == "I" or structure == "G":
+            true_secondary[0].append(truth)
+            prediction_secondary[0].append(pred)
+        elif structure == "E":
+            true_secondary[1].append(truth)
+            prediction_secondary[1].append(pred)
+        elif structure == "B" or structure == "T" or structure == "S":
+            true_secondary[2].append(truth)
+            prediction_secondary[2].append(pred)
+        else:
+            true_secondary[3].append(truth)
+            prediction_secondary[3].append(pred)
+    return sequence, prediction, dssp, true_secondary, prediction_secondary
+
+
+def score(
+    df: pd.DataFrame,
+    predictions: dict,
+    by_fragment: bool = True,
+    ignore_uncommon=False,
+) -> Tuple[List[float], List[float], List[float], List[float], List[float]]:
+    """Concatenates and scores all predicted sequences in the DataFrame.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        DataFrame with CATH fragment info. The frame must have predicted sequence, true sequence and start/stop index of CATH fragment.
+    predictions: dict
+        Dictionary with loaded predictions.
+    by_fragment: bool
+        If true scores only CATH fragments, if False, scores entire chain.
+    ignore_uncommon=True
+        If True, ignores uncommon residues in accuracy calculations.
+    score_sequence=False
+        True if dictionary contains sequences, False if probability matrices(matrix shape n,20).
+
+    Returns
+    --------
+    accuracy: List[float]
+        List with accuracy. Format: [overal,helices,sheets,loops,random].
+    top_three: List[float]
+        List with top_three accuracy. Same format.
+    similarity: List[float]
+        List with similarity scores.
+    recall: List[float]
+        List with macro average recall.
+    precision: List[float]
+        List with macro average precision."""
+    sequence, prediction, dssp, true_secondary, predicted_secondary = format_sequence(
+        df, predictions, by_fragment, ignore_uncommon,
+    )
+    accuracy = []
+    recall = []
+    similarity = []
+    top_three = []
+    precision = []
+
+    most_likely_seq = list(most_likely_sequence(prediction))
+    accuracy.append(metrics.accuracy_score(sequence, most_likely_seq))
+    recall.append(
+        metrics.recall_score(
+            sequence, most_likely_seq, average="macro", zero_division=0
+        )
+    )
+    precision.append(
+        metrics.precision_score(
+            sequence, most_likely_seq, average="macro", zero_division=0
+        )
+    )
+    assert len(sequence)==len(most_likely_seq), "Predicted and true sequence lengths do not match."
+    similarity_score = [
+        1 if lookup_blosum62(a, b) > 0 else 0
+        for a, b in zip(sequence, most_likely_seq)
+    ]
+    if len(similarity_score)>0:
+        similarity.append(sum(similarity_score) / len(similarity_score))
+    else:
+        similarity.append(np.NaN)
+    #check if probabilities or encoded sequences, encoded sequence has 0 entropy.
+    is_prob=sum(entropy(prediction, base=2, axis=1))
+    if is_prob:
+        top_three.append(
+            metrics.top_k_accuracy_score(sequence, prediction, k=3, labels=config.acids)
+        )
+    else:
+         top_three.append(np.NaN)
+    for seq_type in range(len(true_secondary)):
+        # not all architectures have examples of all secondary structure types.
+        if len(true_secondary[seq_type]) > 0:
+            secondary_sequence = list(
+                most_likely_sequence(predicted_secondary[seq_type])
+            )
+            accuracy.append(
+                metrics.accuracy_score(true_secondary[seq_type], secondary_sequence)
+            )
+            recall.append(
+                metrics.recall_score(
+                    true_secondary[seq_type],
+                    secondary_sequence,
+                    average="macro",
+                    zero_division=0,
+                )
+            )
+            precision.append(
+                metrics.precision_score(
+                    true_secondary[seq_type],
+                    secondary_sequence,
+                    average="macro",
+                    zero_division=0,
+                )
+            )
+            assert len(true_secondary[seq_type])==len(secondary_sequence), "True and predicted lengths do not match"
+            similarity_score = [
+                1 if lookup_blosum62(a, b) > 0 else 0
+                for a, b in zip(true_secondary[seq_type], secondary_sequence)
+            ]
+            if is_prob:
+                top_three.append(
+                    metrics.top_k_accuracy_score(
+                        true_secondary[seq_type],
+                        predicted_secondary[seq_type],
+                        k=3,
+                        labels=config.acids,
+                    )
+                )
+            else:
+                top_three.append(np.NaN)
+            similarity.append(sum(similarity_score) / len(similarity_score))
+        else:
+            accuracy.append(np.NaN)
+            top_three.append(np.NaN)
+            similarity.append(np.NaN)
+            recall.append(np.NaN)
+            precision.append(np.NaN)
+    return accuracy, top_three, similarity, recall, precision
+
+
+def score_by_architecture(
+    df: pd.DataFrame,
+    predictions: dict,
+    by_fragment: bool = True,
+    ignore_uncommon: bool = False,
+) -> pd.DataFrame:
+    """Groups predictions by architecture and scores each separately.
+
+    Parameters
+    ----------
+    df:pd.DataFrame
+        DataFrame containing predictions, cath codes and true sequences.
+    predictions: dict,
+        Dictionary with predictions, key is PDB+chain.
+    by_fragment: bool =True
+        If true scores only CATH fragments, if False, scores entire chain.
+    ignore_uncommon:bool=False
+        If true, skips uncommon amino acids when formating true sequence.
+    score_sequence:bool =False
+        Set to True if scoring a sequence, False if scoring a probability array.
+
+    Returns
+    -------
+    DataFrame with accuracy, similarity, recall and precision for each architecture type."""
+
+    architectures = df.drop_duplicates(subset=["class", "architecture"])[
+        "architecture"
+    ].values
+    classes = df.drop_duplicates(subset=["class", "architecture"])["class"].values
+    scores = []
+    names = []
+    assert len(classes)==len(architectures), "Number of entries in classes and architectures do not match, this is impossible."
+    for cls, arch in zip(classes, architectures):
+        accuracy, top_three, similarity, recall, precision = score(
+            get_pdbs(df, cls, arch),
+            predictions,
+            by_fragment,
+            ignore_uncommon,
+        )
+        scores.append(
+            [accuracy[0], top_three[0], similarity[0], recall[0], precision[0]]
+        )
+        # lookup normal names
+        names.append(config.architectures[f"{cls}.{arch}"])
+    score_frame = pd.DataFrame(
+        scores,
+        columns=["accuracy", "top3_accuracy", "similarity", "recall", "precision"],
+        index=[classes, architectures],
+    )
+    score_frame["name"] = names
+    return score_frame
+
+
+def score_each(
+    df: pd.DataFrame,
+    predictions: dict,
+    by_fragment: bool = True,
+    ignore_uncommon=False,
+) -> Tuple[List[float], List[float]]:
+    """Calculates accuracy and recall for each protein in DataFrame separately.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        DataFrame with CATH fragment info. The frame must have predicted sequence, true sequence and start/stop index of CATH fragment.
+    predictions: dict
+        Dictionary with loaded predictions.
+    by_fragment: bool
+        If true scores only CATH fragments, if False, scores entire chain.
+    ignore_uncommon=True
+        If True, ignores uncommon residues in accuracy calculations.
+    score_sequence=False
+        True if dictionary contains sequences, False if probability matrices(matrix shape n,20).
+
+    Returns
+    --------
+    accuracy: List[float]
+        List with accuracy for each protein in DataFrame
+    recall: List[float]
+        List with macro average recall for each protein in Dataframe."""
+
+    accuracy = []
+    recall = []
+    for i, protein in df.iterrows():
+        if protein.PDB + protein.chain in predictions:
+            start = protein.start
+            stop = protein.stop
+            predicted_sequence = predictions[protein.PDB + protein.chain]
+
+            # remove uncommon acids
+            if ignore_uncommon and type(protein.uncommon_index)==list:
+                protein_sequence = "".join(
+                    [
+                        x
+                        for i, x in enumerate(protein.sequence)
+                        if i not in protein.uncommon_index
+                    ]
+                )
+                start = start - (np.array(protein.uncommon_index) <= start).sum()
+                stop = stop - (np.array(protein.uncommon_index) <= stop).sum()
+            else:
+                protein_sequence = protein.sequence
+
+            # check length
+            if len(protein_sequence) != len(predicted_sequence):
+                # prediction is multimer
+                if len(predicted_sequence) % len(protein_sequence) == 0:
+                    predicted_sequence = predicted_sequence[0 : len(protein_sequence)]
+                else:
+                    print(
+                        f"{protein.PDB}{protein.chain} sequence, predicted sequence and dssp length do not match."
+                    )
+                    accuracy.append(np.NaN)
+                    recall.append(np.NaN)
+                    continue
+            if by_fragment:
+                protein_sequence = protein_sequence[start : stop + 1]
+                predicted_sequence = predicted_sequence[start : stop + 1]
+            
+            accuracy.append(
+                metrics.accuracy_score(
+                    list(protein_sequence),
+                    list(most_likely_sequence(predicted_sequence)),
+                )
+            )
+            recall.append(
+                metrics.recall_score(
+                    list(protein_sequence),
+                    list(most_likely_sequence(predicted_sequence)),
+                    average="macro",
+                    zero_division=0,
+                )
+            )
+        else:
+            accuracy.append(np.NaN)
+            recall.append(np.NaN)
+
+    return accuracy, recall
+
+
+def get_by_residue_metrics(
+    sequence: np.array, prediction: np.array,
+) -> pd.DataFrame:
+    """Calculates recall,precision and f1 for each amino acid.
+    Parameters
+    ----------
+    sequence:np.array
+        True sequence array with characters.
+    prediction:np.array
+        Predicted sequence, array with characters or probability matrix.
+
+    Returns
+    -------
+    entropy_frame:pd.DataFrame
+        DataFrame with recall, precision, f1 score, entropy and AUC for each amino acids.
+    """
+
+    entropy_arr = entropy(prediction, base=2, axis=1)
+    # calculate auc values
+    labels = LabelBinarizer().fit(config.acids).transform(sequence)
+    roc_auc = []
+    for i in range(len(config.acids)):
+        fpr, tpr, _ = metrics.roc_curve(labels[:, i], prediction[:, i])
+        roc_auc.append(metrics.auc(fpr, tpr))
+    prediction = list(most_likely_sequence(prediction))
+
+    # prevents crashing when not all amino acids are predicted
+    entropy_frame = pd.DataFrame(index=config.acids)
+    entropy_frame = entropy_frame.join(
+        pd.DataFrame({"sequence": prediction, "entropy": entropy_arr})
+        .groupby(by="sequence")
+        .mean()
+    )
+    prec, rec, f1, sup = metrics.precision_recall_fscore_support(sequence, prediction)
+
+    entropy_frame.loc[:, "recall"] = rec
+    entropy_frame.loc[:, "precision"] = prec
+    entropy_frame.loc[:, "f1"] = f1
+    entropy_frame.loc[:, "auc"] = roc_auc
+    return entropy_frame
+
+
+def get_angles(protein: pd.Series, path_to_assemblies: Path) -> np.array:
+    """Gets backbone torsion angles for protein.
+
+    Parameters
+    ----------
+        protein: pd.Series
+            Series containing protein info.
+        path_to_assemblies: Path
+            Path to the directory with biological assemblies.
+    Returns
+    -------
+    torsion_angles: np.array
+        Array with torsion angles."""
+
+    path = path_to_assemblies / protein.PDB[1:3] / f"pdb{protein.PDB}.ent.gz"
+    if path.exists():
+        with gzip.open(path, "rb") as file:
+            assembly = ampal.load_pdb(file.read().decode(), path=False)
+            # check is assembly has multiple states, pick the first
+            if isinstance(assembly, ampal.AmpalContainer):
+                assembly = assembly[0]
+            chain = assembly[protein.chain]
+            torsion_angles = ampal.analyse_protein.measure_torsion_angles(chain)
+    return torsion_angles
+
+
+def format_angle_sequence(
+    df: pd.DataFrame,
+    predictions: dict,
+    path_to_assemblies: Path,
+    by_fragment: bool = False,
+    ignore_uncommon=False,
+) -> Tuple[str, Iterable, str, List[List[float]]]:
+    """Gets Psi and Phi angles for all residues in predictions, can skip uncommon acids.
+
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        DataFrame with CATH fragment info. The frame must have predicted sequence, true sequence and start/stop index of CATH fragment.
+    predictions: dict
+        Dictionary with loaded predictions.
+    path_to_assemblies: Path
+        Path to the directory with biological assemblies.
+    by_fragment: bool
+        If true scores only CATH fragments, if False, scores entire chain.
+    ignore_uncommon=True
+        If True, ignores uncommon residues in accuracy calculations.
+        
+    Returns
+    -------
+    sequece:str
+        Protein sequence.
+    prediction: str or np.array
+        Predicted protein sequence or probability matrix.
+    dssp: str
+        String with dssp data
+    torsion:List[List[float]]
+        List with torsion angles. Format:[[omega,phi,psi]].
+    """
+
+    sequence = ""
+    dssp = ""
+    torsion = []
+    prediction = np.empty([0, 20])
+    for i, protein in df.iterrows():
+        if protein.PDB + protein.chain in predictions:
+            start = protein.start
+            stop = protein.stop
+            predicted_sequence = predictions[protein.PDB + protein.chain]
+            protein_angle = get_angles(protein, path_to_assemblies)
+
+            # remove uncommon acids
+            if ignore_uncommon and type(protein.uncommon_index)==list:
+                protein_sequence = "".join(
+                    [
+                        x
+                        for i, x in enumerate(protein.sequence)
+                        if i not in protein.uncommon_index
+                    ]
+                )
+                protein_dssp = "".join(
+                    [
+                        x
+                        for i, x in enumerate(protein.dssp)
+                        if i not in protein.uncommon_index
+                    ]
+                )
+                protein_angle = [
+                    x
+                    for i, x in enumerate(protein_angle)
+                    if i not in protein.uncommon_index
+                ]
+                # update start and stop indexes
+                start = start - (np.array(protein.uncommon_index) <= start).sum()
+                stop = stop - (np.array(protein.uncommon_index) <= stop).sum()
+            else:
+                protein_sequence = protein.sequence
+                protein_dssp = protein.dssp
+
+            # check length
+            if len(protein_sequence) != len(predicted_sequence):
+                # prediction is multimer
+                if len(predicted_sequence) % len(protein_sequence) == 0:
+                    predicted_sequence = predicted_sequence[0 : len(protein_sequence)]
+                else:
+                    print(
+                        f"{protein.PDB}{protein.chain} sequence, predicted sequence and dssp length do not match."
+                    )
+                    continue
+
+            if by_fragment:
+                protein_sequence = protein_sequence[start : stop + 1]
+                protein_dssp = protein_dssp[start : stop + 1]
+                predicted_sequence = predicted_sequence[start : stop + 1]
+                protein_angle = protein_angle[start : stop + 1]
+
+            if (
+                len(protein_sequence) == len(predicted_sequence)
+                and len(protein_sequence) == len(protein_dssp)
+                and len(protein_angle) == len(predicted_sequence)
+            ):
+                sequence += protein_sequence
+                dssp += protein_dssp
+                torsion += protein_angle
+                prediction = np.concatenate(
+                    [prediction, predicted_sequence], axis=0
+                    )
+            else:
+                print(
+                    f"{protein.PDB}{protein.chain} sequence, predicted sequence and dssp length do not match."
+                )
+
+    return sequence, prediction, dssp, torsion

data/benchmark/version.py

@@ -0,0 +1 @@
+__version__ = "0.1_30d75dc"

data/benchmark/visualization.py

@@ -0,0 +1,1101 @@
+"""Functions for visualizing metrics and comparing different models"""
+
+import pandas as pd
+from benchmark import config
+import ampal
+from benchmark import get_cath
+import gzip
+from pathlib import Path
+import numpy as np
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import matplotlib.patches as mpatches
+from sklearn import metrics
+import matplotlib.backends.backend_pdf
+from scipy.stats import entropy
+from typing import List
+from benchmark import version
+from scipy.stats import pearsonr
+
+def _annotate_ampalobj_with_data_tag(
+    ampal_structure,
+    data_to_annotate,
+    tags,
+) -> ampal.assembly:
+    """
+    Assigns a data point to each residue equivalent to the prediction the
+    tag value. The original value of the tag will be reset to the minimum value
+    to allow for a more realistic color comparison.
+    Parameters
+    ----------
+    ampal_structure : ampal.Assembly or ampal.AmpalContainer
+        Ampal structure to be modified. If an ampal.AmpalContainer is passed,
+        this will take the first Assembly in the ampal.AmpalContainer `ampal_structure[0]`.
+    data_to_annotate : numpy.ndarray of numpy.ndarray of floats
+        Numpy array with data points to annotate (x, n) where x is the
+        numer of arrays with data points (eg, [ entropy, accuracy ] ,
+        x = 2n) and n is the number of residues in the structure.
+    tags : t.List[str]
+        List of string tags of the pdb object (eg. "b-factor")
+    Returns
+    -------
+    ampal_structure : Assembly
+        Ampal structure with modified B-factor and occupancy values.
+
+    Notes
+    -----
+    Leo's code.
+    Same as _annotate_ampalobj_with_data_tag from TIMED but can deal with missing unnatural amino acids for compatibility with EvoEF2."""
+
+    assert len(tags) == len(
+        data_to_annotate
+    ), "The number of tags to annotate and the type of data to annotate have different lengths."
+
+    if len(data_to_annotate) > 1:
+        assert len(data_to_annotate[0]) == len(data_to_annotate[1]), (
+            f"Data to annotatate has shape {len(data_to_annotate[0])} and "
+            f"{len(data_to_annotate[1])}. They should be the same."
+        )
+
+    for i, tag in enumerate(tags):
+        # Reset existing values:
+        for atom in ampal_structure.get_atoms(ligands=True, inc_alt_states=True):
+            atom.tags[tag] = np.min(data_to_annotate[i])
+
+    # Apply data as tag:
+    for i, tag in enumerate(tags):
+
+        # Check if chain is Polypeptide (it might be DNA for example...)
+        if isinstance(ampal_structure, ampal.Polypeptide):
+            if len(ampal_structure) != len(data_to_annotate[i]):
+                # EvoEF2 predictions drop uncommon amino acids
+                if len(ampal_structure) - ampal_structure.sequence.count("X") == len(
+                    data_to_annotate[i]
+                ):
+                    for residue in ampal_structure:
+                        counter = 0
+                        if ampal.amino_acids.get_aa_letter(residue) == "X":
+                            continue
+                        else:
+                            for atom in residue:
+                                atom.tags[tag] = data_to_annotate[i][counter]
+                                counter += 1
+                else:
+                    print("Length is not equal")
+                    return
+            for residue, data_val in zip(ampal_structure, data_to_annotate[i]):
+                for atom in residue:
+                    atom.tags[tag] = data_val
+
+    return ampal_structure
+
+
+def show_accuracy(
+    df: pd.DataFrame,
+    pdb: str,
+    predictions: dict,
+    output: Path,
+    path_to_pdbs: Path,
+    ignore_uncommon: bool,
+) -> None:
+    """
+    Parameters
+    ----------
+    df: pd.DataFrame
+        CATH dataframe.
+    pdb: str
+      PDB code to visualize, format: pdb+CHAIN.
+    predictions: dict
+        Dictionary with predicted sequences, key is PDB+chain.
+    name: str
+        Location of the .pdf file, also title of the plot.
+    output: Path
+        Path to output directory.
+    path_to_pdbs: Path
+        Path to the directory with PDB files.
+    ignore_uncommon=True
+        If True, ignores uncommon residues in accuracy calculations.
+    score_sequence=False
+        True if dictionary contains sequences, False if probability matrices(matrix shape n,20)."""
+    accuracy = []
+    pdb_df = df[df.PDB == pdb]
+    sequence, prediction, _, _, _ = get_cath.format_sequence(
+        pdb_df, predictions, False, ignore_uncommon,
+    )
+    
+    entropy_arr = entropy(prediction, base=2, axis=1)
+    prediction = list(get_cath.most_likely_sequence(prediction))
+    for resa, resb in zip(sequence, prediction):
+        """correct predictions are given constant score so they stand out in the figure.
+        e.g., spectrum q, blue_white_red, maximum=6,minimum=-6 gives nice plots. Bright red shows correct predictions
+        Red shades indicate substitutions with positive score, white=0, blue shades show substiutions with negative score.
+        cartoon putty shows nice entropy visualization."""
+
+        if resa == resb:
+            accuracy.append(6)
+        # incorrect predictions are coloured by blossum62 score.
+        else:
+            accuracy.append(get_cath.lookup_blosum62(resa, resb))
+    path_to_protein = path_to_pdbs / pdb[1:3] / f"pdb{pdb}.ent.gz"
+    with gzip.open(path_to_protein, "rb") as protein:
+        assembly = ampal.load_pdb(protein.read().decode(), path=False)
+
+    # Deals with structures from NMR as ampal returns Container of Assemblies
+    if isinstance(assembly, ampal.AmpalContainer):
+        warnings.warn(f"Selecting the first state from the NMR structure {assembly.id}")
+        assembly = assembly[0]
+    # select correct chain
+    assembly = assembly[pdb_df.chain.values[0]]
+    
+    curr_annotated_structure = _annotate_ampalobj_with_data_tag(
+        assembly, [accuracy, entropy_arr], tags=["occupancy","bfactor"]
+    )
+    with open(output, "w") as f:
+        f.write(curr_annotated_structure.pdb)
+
+
+def ramachandran_plot(
+    sequence: List[chr], prediction: List[chr], torsions: List[List[float]], name: str
+) -> None:
+    """Plots predicted and true Ramachandran plots for each amino acid. All plots are normalized by true residue count. Takes at least a minute to plot these, so don't plot if not neccessary.
+    Parameters
+    ----------
+    sequence: List[chr]
+        List with correctly formated (get_cath.format_format_angle_sequence()) sequence.
+    prediction: List[chr]
+        List with correctly formated predictions. Amino acid sequence, not arrays.
+    torsions: List[List[float]]
+        List wit correctly formated torsion angles.
+    name: str
+        Name and location of the figure."""
+
+    fig, ax = plt.subplots(20, 3, figsize=(15, 100))
+    plt.figtext(0.1, 0.99,s='Version: '+version.__version__,figure=fig,fontdict={"size": 12})
+    # get angles for each amino acids
+    for k, amino_acid in enumerate(config.acids):
+        predicted_angles = [
+            x for x, residue in zip(torsions, prediction) if residue == amino_acid
+        ]
+        predicted_psi = [
+            x[2] for x in predicted_angles if (x[2] != None) & (x[1] != None)
+        ]
+        predicted_phi = [
+            x[1] for x in predicted_angles if (x[1] != None) & (x[2] != None)
+        ]
+
+        true_angles = [
+            x for x, residue in zip(torsions, list(sequence)) if residue == amino_acid
+        ]
+        true_psi = [x[2] for x in true_angles if (x[2] != None) & (x[1] != None)]
+        true_phi = [x[1] for x in true_angles if (x[1] != None) & (x[2] != None)]
+
+        # make a histogram and normalize by residue count
+        array, xedges, yedges = [
+            x
+            for x in np.histogram2d(
+                predicted_psi, predicted_phi, bins=50, range=[[-180, 180], [-180, 180]]
+            )
+        ]
+        array = array / len(true_psi)
+        true_array, xedges, yedges = [
+            x
+            for x in np.histogram2d(
+                true_psi, true_phi, bins=50, range=[[-180, 180], [-180, 180]]
+            )
+        ]
+        true_array = true_array / len(true_psi)
+        difference = true_array - array
+        # get minimum and maximum counts for true and predicted sequences, use this to keep color maping in both plots identical. Easier to see overprediction.
+        minimum = np.amin([array, true_array])
+        maximum = np.amax([array, true_array])
+        # change 0 counts to NaN to show white space.
+        # make Ramachandran plot for predictions.
+        for i, rows in enumerate(array):
+            for j, cols in enumerate(rows):
+                if cols == 0.0:
+                    array[i][j] = np.NaN
+
+        im = ax[k][0].imshow(
+            array,
+            interpolation="none",
+            origin='lower',
+            norm=None,
+            extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]],
+            cmap="viridis",
+            vmax=maximum,
+            vmin=minimum,
+        )
+        fig.colorbar(im, ax=ax[k][0], fraction=0.046)
+        ax[k][0].set_xlim(-180, 180)
+        ax[k][0].set_ylim(-180, 180)
+        ax[k][0].set_xticks(np.arange(-180, 220, 40))
+        ax[k][0].set_yticks(np.arange(-180, 220, 40))
+        ax[k][0].set_ylabel("Psi")
+        ax[k][0].set_xlabel("Phi")
+        ax[k][0].set_title(f"Predicted {amino_acid}")
+
+        # Make Ramachandran plot for true sequence.
+        for i, rows in enumerate(true_array):
+            for j, cols in enumerate(rows):
+                if cols == 0.0:
+                    true_array[i][j] = np.NaN
+        im = ax[k][1].imshow(
+            true_array,
+            interpolation="none",
+            origin='lower',
+            norm=None,
+            extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]],
+            cmap="viridis",
+            vmax=maximum,
+            vmin=minimum,
+        )
+        fig.colorbar(im, ax=ax[k][1], fraction=0.046)
+        ax[k][1].set_xlim(-180, 180)
+        ax[k][1].set_ylim(-180, 180)
+        ax[k][1].set_xticks(np.arange(-180, 220, 40))
+        ax[k][1].set_yticks(np.arange(-180, 220, 40))
+        ax[k][1].set_ylabel("Psi")
+        ax[k][1].set_xlabel("Phi")
+        ax[k][1].set_title(f"True {amino_acid}")
+
+        # Make difference plots.
+        for i, rows in enumerate(difference):
+            for j, cols in enumerate(rows):
+                if cols == 0.0:
+                    difference[i][j] = np.NaN
+
+        im = ax[k][2].imshow(
+            difference,
+            interpolation="none",
+            origin='lower',
+            norm=None,
+            extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]],
+            cmap="viridis",
+        )
+        fig.colorbar(im, ax=ax[k][2], fraction=0.046)
+        ax[k][2].set_xlim(-180, 180)
+        ax[k][2].set_ylim(-180, 180)
+        ax[k][2].set_xticks(np.arange(-180, 220, 40))
+        ax[k][2].set_yticks(np.arange(-180, 220, 40))
+        ax[k][2].set_ylabel("Psi")
+        ax[k][2].set_xlabel("Phi")
+        ax[k][2].set_title(f"True-Predicted {amino_acid}")
+
+    plt.tight_layout()
+    plt.savefig(name + "_Ramachandran_plot.pdf")
+    plt.close()
+
+
+def append_zero_residues(arr: np.array) -> np.array:
+    """Sets missing residue count to 0. Needed for per residue metrics plot.
+    Parameters
+    ----------
+    arr:np.array
+        Array returned by np.unique() with residues and their counts.
+    Returns
+    -------
+    np.array with added mising residues and 0 counts."""
+    if len(arr[0]) != 20:
+        temp_dict = {res_code: res_count for res_code, res_count in zip(arr[0], arr[1])}
+        for residue in config.acids:
+            if residue not in temp_dict:
+                temp_dict[residue] = 0
+        arr = [[], []]
+        arr[1] = [x[1] for x in sorted(temp_dict.items())]
+        arr[0] = [x[0] for x in sorted(temp_dict.items())]
+    return arr
+
+
+def make_model_summary(
+    df: pd.DataFrame,
+    predictions: dict,
+    name: str,
+    path_to_pdb: Path,
+    ignore_uncommon: bool = False,
+) -> None:
+    """
+    Makes a .pdf report whith model metrics.
+    Includes prediction bias, accuracy and macro recall for each secondary structure, accuracy and recall correlation with protein resolution, confusion matrices and accuracy, recall and f1 score for each resiude.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        CATH dataframe.
+    predictions: dict
+        Dictionary with predicted sequences, key is PDB+chain.
+    name: str
+        Location of the .pdf file, also title of the plot.
+    path_to_pdb: Path
+        Path to the directory with PDB files.
+    ignore_uncommon=True
+        If True, ignores uncommon residues in accuracy calculations.
+    """
+    
+    fig, ax = plt.subplots(ncols=5, nrows=5, figsize=(30, 40))
+    #print version
+    plt.figtext(0.1, 0.99,s='Version: '+version.__version__,figure=fig,fontdict={"size": 12})
+    # show residue distribution and confusion matrix
+    (
+        sequence,
+        prediction,
+        _,
+        true_secondary,
+        prediction_secondary,
+    ) = get_cath.format_sequence(
+        df,
+        predictions,
+        ignore_uncommon=ignore_uncommon,
+        by_fragment=False,
+    )
+    # get info about each residue
+    by_residue_frame = get_cath.get_by_residue_metrics(
+        sequence, prediction
+    )
+    # convert probability array into list of characters.
+    prediction = list(get_cath.most_likely_sequence(prediction))
+    prediction_secondary = [
+        list(get_cath.most_likely_sequence(ss_seq))
+        for ss_seq in prediction_secondary
+    ]
+
+    seq = append_zero_residues(np.unique(sequence, return_counts=True))
+
+    pred = append_zero_residues(np.unique(prediction, return_counts=True))
+    index = np.arange(len(seq[0]))
+    # calculate prediction bias
+    residue_bias = pred[1] / sum(pred[1]) - seq[1] / sum(seq[1])
+    #keep max bias to scale all graphs
+    max_bias=max(residue_bias)
+    ax[3][4].bar(x=index, height=residue_bias, width=0.8, align="center")
+    ax[3][4].set_ylabel("Prediction bias")
+    ax[3][4].set_xlabel("Amino acids")
+    for e, dif in enumerate(residue_bias):
+        if dif < 0:
+            y_coord = 0
+        else:
+            y_coord = dif
+        ax[3][4].text(
+            index[e],
+            y_coord*1.05,
+            f"{dif:.3f}",
+            ha="center",
+            va="bottom",
+            rotation="vertical",
+        )
+
+    ax[3][4].set_xticks(index)
+    ax[3][4].set_xticklabels(
+        pred[0], fontdict={"horizontalalignment": "center", "size": 12}
+    )
+    ax[3][4].set_ylabel("Prediction bias")
+    ax[3][4].set_xlabel("Amino acids")
+    ax[3][4].set_title("All structures")
+    ax[3][4].set_ylim(top=1.0)
+
+    cm = metrics.confusion_matrix(sequence, prediction, labels=seq[0])
+    cm = cm.astype("float") / cm.sum(axis=1)[:, np.newaxis]
+
+    im = ax[4][4].imshow(cm, vmin=0, vmax=1)
+    ax[4][4].set_xlabel("Predicted")
+    ax[4][4].set_xticks(range(20))
+    ax[4][4].set_xticklabels(config.acids)
+    ax[4][4].set_ylabel("True")
+    ax[4][4].set_yticks(range(20))
+    ax[4][4].set_yticklabels(config.acids)
+    # Plot Color Bar:
+    fig.colorbar(im, ax=ax[4][4], fraction=0.046)
+
+    # plot prediction bias
+    ss_names = ["Helices", "Sheets", "Structured loops", "Random"]
+    for i, ss in enumerate(ss_names):
+        seq = append_zero_residues(np.unique(true_secondary[i], return_counts=True))
+        pred = append_zero_residues(
+            np.unique(prediction_secondary[i], return_counts=True)
+        )
+        residue_bias = pred[1] / sum(pred[1]) - seq[1] / sum(seq[1])
+        if max(residue_bias)>max_bias:
+            max_bias=max(residue_bias)
+        ax[3][i].bar(x=index, height=residue_bias, width=0.8, align="center")
+        ax[3][i].set_xticks(index)
+        ax[3][i].set_xticklabels(
+            pred[0], fontdict={"horizontalalignment": "center", "size": 12}
+        )
+        ax[3][i].set_ylabel("Prediction bias")
+        ax[3][i].set_xlabel("Amino acids")
+        ax[3][i].set_title(ss)
+        ax[3][i].set_ylim(top=1.0)
+        for e, dif in enumerate(residue_bias):
+            if dif < 0:
+                y_coord = 0
+            else:
+                y_coord = dif
+            ax[3][i].text(
+                index[e],
+                y_coord*1.05,
+                f"{dif:.3f}",
+                ha="center",
+                va="bottom",
+                rotation="vertical",
+            )
+        #plot confusion matrix
+        cm = metrics.confusion_matrix(
+            true_secondary[i], prediction_secondary[i], labels=seq[0]
+        )
+        cm = cm.astype("float") / cm.sum(axis=1)[:, np.newaxis]
+        im = ax[4][i].imshow(cm, vmin=0, vmax=1)
+        ax[4][i].set_xlabel("Predicted")
+        ax[4][i].set_xticks(range(20))
+        ax[4][i].set_xticklabels(config.acids)
+        ax[4][i].set_ylabel("True")
+        ax[4][i].set_yticks(range(20))
+        ax[4][i].set_yticklabels(config.acids)
+        # Plot Color Bar:
+        fig.colorbar(im, ax=ax[4][i], fraction=0.046)
+    
+    #scale all bias plots so that they have the same y-axis.
+    for i in range(5):
+        ax[3][i].set_ylim(ymax=max_bias*1.1)
+
+    # show accuracy,recall,similarity, precision and top3
+    index = np.array([0, 1, 2, 3, 4])
+    
+    accuracy, top_three, similarity, recall, precision = get_cath.score(
+        df, predictions, False, ignore_uncommon,
+    )
+    # show accuracy
+    ax[0][0].bar(x=index, height=accuracy, width=0.8, align="center")
+
+    # show recall
+    ax[0][1].bar(x=index, height=recall, width=0.8, align="center")
+    ax[0][3].bar(x=index, height=precision, width=0.8, align="center")
+    ax[0][4].bar(x=index, height=similarity, width=0.8, align="center")
+    # add values to the plot
+    # show top_3 accuracy if available
+    if not np.isnan(top_three[0]):
+        ax[0][0].scatter(x=index, y=top_three, marker="_", s=50, color="blue")
+        ax[0][0].vlines(x=index, ymin=0, ymax=top_three, linewidth=2)
+        for e, value in enumerate(accuracy):
+            ax[0][0].text(
+                index[e],
+                top_three[e]+0.01,
+                f"{value:.3f}",
+                ha="center",
+                va="bottom",
+                rotation="vertical",
+            )
+    else:
+        for e, value in enumerate(accuracy):
+            ax[0][0].text(
+                index[e],
+                value+0.01,
+                f"{value:.3f}",
+                ha="center",
+                va="bottom",
+                rotation="vertical",
+            )
+    for e, value in enumerate(recall):
+        ax[0][1].text(
+            index[e],
+            value+0.01,
+            f"{value:.3f}",
+            ha="center",
+            va="bottom",
+            rotation="vertical",
+        )
+    for e, value in enumerate(precision):
+        ax[0][3].text(
+            index[e],
+            value * 1.05,
+            f"{value:.3f}",
+            ha="center",
+            va="bottom",
+            rotation="vertical",
+        )
+    for e, value in enumerate(similarity):
+        ax[0][4].text(
+            index[e],
+            value+0.01,
+            f"{value:.3f}",
+            ha="center",
+            va="bottom",
+            rotation="vertical",
+        )
+    # show difference
+
+    difference = np.array(accuracy) - np.array(recall)
+    maximum = np.amax(difference)
+    ax[0][2].bar(x=index, height=difference, width=0.8, align="center")
+    for e, dif in enumerate(difference):
+        if dif < 0:
+            y_coord = 0
+        else:
+            y_coord = dif
+        ax[0][2].text(
+            index[e],
+            y_coord+0.01,
+            f"{dif:.3f}",
+            ha="center",
+            va="bottom",
+            rotation="vertical",
+        )
+    # Title, label, ticks and limits
+    ax[0][0].set_ylabel("Accuracy")
+    ax[0][0].set_xticks(index)
+    ax[0][0].set_xticklabels(
+        ["All structures", "Helices", "Sheets", "Structured loops", "Random"],
+        rotation=90,
+        fontdict={"horizontalalignment": "center", "size": 12},
+    )
+    ax[0][0].set_ylim(0, 1)
+    ax[0][0].set_xlim(-0.7, index[-1] + 1)
+
+    ax[0][1].set_ylabel("MacroRecall")
+    ax[0][1].set_xticks(index)
+    ax[0][1].set_xticklabels(
+        ["All structures", "Helices", "Sheets", "Structured loops", "Random"],
+        rotation=90,
+        fontdict={"horizontalalignment": "center", "size": 12},
+    )
+    ax[0][1].set_ylim(0, 1)
+    ax[0][1].set_xlim(-0.7, index[-1] + 1)
+
+    ax[0][2].set_ylabel("Accuracy-MacroRecall")
+    ax[0][2].set_xticks(index)
+    ax[0][2].set_xticklabels(
+        ["All structures", "Helices", "Sheets", "Structured loops", "Random"],
+        rotation=90,
+        fontdict={"horizontalalignment": "center", "size": 12},
+    )
+    ax[0][2].set_xlim(-0.7, index[-1] + 1)
+    ax[0][2].axhline(0, -0.3, index[-1] + 1, color="k", lw=1)
+    ax[0][2].set_ylim(ymax=maximum * 1.2)
+
+    ax[0][3].set_ylabel("MacroPrecision")
+    ax[0][3].set_xticks(index)
+    ax[0][3].set_xticklabels(
+        ["All structures", "Helices", "Sheets", "Structured loops", "Random"],
+        rotation=90,
+        fontdict={"horizontalalignment": "center", "size": 12},
+    )
+    ax[0][3].set_ylim(0, 1)
+    ax[0][3].set_xlim(-0.7, index[-1] + 1)
+
+    ax[0][4].set_ylabel("Similarity")
+    ax[0][4].set_xticks(index)
+    ax[0][4].set_xticklabels(
+        ["All structures", "Helices", "Sheets", "Structured loops", "Random"],
+        rotation=90,
+        fontdict={"horizontalalignment": "center", "size": 12},
+    )
+    ax[0][4].set_ylim(0, 1)
+    ax[0][4].set_xlim(-0.7, index[-1] + 1)
+
+    colors = sns.color_palette("viridis", 4)
+    # combine classes 4 and 6 to simplify the graph
+    colors = {1: colors[0], 2: colors[1], 3: colors[2], 4: colors[3], 6: colors[3]}
+    class_color = [colors[x] for x in df["class"].values]
+    # show accuracy and macro recall resolution distribution
+    accuracy, recall = get_cath.score_each(
+        df,
+        predictions,
+        ignore_uncommon=ignore_uncommon,
+        by_fragment=True,
+    )
+    #this is [nan,nan,...] if NMR.
+    resolution = get_cath.get_resolution(df, path_to_pdb)
+    #NMR does not have resolution, full NMR set would crash np.polyfit.
+    if not np.isnan(resolution).all():
+    
+        # calculate Pearson correlation between accuracy/recall and resolution.
+        res_df = pd.DataFrame({'res': resolution, 'recall': recall, 'accuracy': accuracy}).dropna()
+        corr=res_df.corr().to_numpy()
+        #linear fit
+        m, b = np.polyfit(res_df['res'], res_df['accuracy'], 1)
+        ax[1][3].plot(res_df['res'], m*res_df['res'] + b, color='r')
+        ax[1][3].scatter(resolution, accuracy, color=class_color, alpha=0.7)
+        # Title, label, ticks and limits
+        ax[1][3].set_xlabel("Resolution, A")
+        ax[1][3].set_ylabel("Accuracy")
+        ax[1][3].set_title(f"Pearson correlation: {corr[0][2]:.3f}")
+        m, b = np.polyfit(res_df['res'], res_df['recall'], 1)
+        ax[1][4].plot(res_df['res'], m*res_df['res'] + b, color='r')
+        ax[1][4].scatter(resolution, recall, color=class_color, alpha=0.7)
+        ax[1][4].set_title(f"Pearson correlation: {corr[0][1]:.3f}")
+        ax[1][4].set_ylabel("MacroRecall")
+        ax[1][4].set_xlabel("Resolution, A")
+        # make a legend
+        patches = [
+            mpatches.Patch(color=colors[x], label=config.classes[x]) for x in config.classes
+        ]
+        ax[1][4].legend(loc=1, handles=patches, prop={"size": 9})
+        ax[1][3].legend(loc=1, handles=patches, prop={"size": 9})
+        
+    # show per residue metrics about the model
+    gs = ax[0, 0].get_gridspec()
+    # show per residue entropy
+    ax[2][0].bar(by_residue_frame.index, by_residue_frame.entropy)
+    ax[2][0].set_ylabel("Entropy")
+    ax[2][0].set_xlabel("Amino acids")
+
+    # make one big subplot
+    for a in ax[2, 1:]:
+        a.remove()
+    ax_right = fig.add_subplot(gs[2, 1:])
+    index = np.arange(len(by_residue_frame.index))
+    # show recall,precision and f1
+    for i, metric in enumerate(["recall", "precision", "f1"]):
+        ax_right.bar(
+            index + i * 0.3, height=by_residue_frame[metric], width=0.3, label=metric
+        )
+        # add values to the plot
+        for j, value in enumerate(by_residue_frame[metric]):
+            ax_right.text(
+                index[j] + i * 0.3,
+                value + 0.05,
+                f"{value:.3f}",
+                ha="center",
+                va="bottom",
+                rotation="vertical",
+            )
+    ax_right.legend()
+    ax_right.set_xticks(index + 0.3)
+    ax_right.set_xticklabels(
+        by_residue_frame.index, fontdict={"horizontalalignment": "center", "size": 12}
+    )
+    ax_right.set_xlim(index[0] - 0.3, index[-1] + 1)
+    ax_right.set_ylim(0, 1)
+
+    #show auc values
+    ax[1][0].bar(by_residue_frame.index, by_residue_frame.auc)
+    ax[1][0].set_ylabel("AUC")
+    ax[1][0].set_xlabel("Amino acids")
+    ax[1][0].set_ylim(0, 1)
+    #Remove empty subplots.
+    ax[1][1].remove()
+    ax[1][2].remove()
+
+
+
+    plt.suptitle(name, fontsize="xx-large")
+    fig.tight_layout(rect=[0, 0.03, 1, 0.98])
+    fig.savefig(name + ".pdf")
+    plt.close()
+
+
+def compare_model_accuracy(
+    df: pd.DataFrame,
+    model_scores: List[dict],
+    model_labels: List[str],
+    location: Path,
+    ignore_uncommon: List[bool],
+) -> None:
+    """
+    Compares all the models in model_scores.
+    .pdf report contains accuracy, macro average and similarity scores for each CATH architecture and secondary structure type.
+
+    Parameters
+    ----------
+
+    df: pd.DataFrame
+        CATH dataframe.
+    model_scores: List[dict]
+        List with dictionary with predicted sequences.
+    model_labels: List[str]
+        List with model names corresponding to dictionaries in model_scores.
+    location:Path
+        Location where to store the .pdf file.
+    ignore_uncommon=List[bool]
+        If True, ignores uncommon residues in accuracy calculations. Required for EvoEF2."""
+
+    models = []
+    
+    #remove .csv extenstion from labels
+    model_labels=[x[:-4] for x in model_labels]
+    
+    for model, ignore in zip(model_scores, ignore_uncommon):
+        models.append(
+            get_cath.score_by_architecture(
+                df,
+                model,
+                ignore_uncommon=ignore,
+                by_fragment=True,
+            )
+        )
+    
+    # Plot CATH architectures
+    minimum = 0
+    maximum = 0
+    colors = sns.color_palette()
+    # combine classes 4 and 6 to make plots nicer. Works with any number of CATH classes.
+    class_key = [x[0] for x in models[0].index]
+    class_key = list(dict.fromkeys(class_key))
+    if 4 in class_key and 6 in class_key:
+        class_key = [x for x in class_key if x != 4 and x != 6]
+        class_key.append([4, 6])
+    # calculate subplot ratios so that classes with more architectures have more space.
+    ratios = [models[0].loc[class_key[i]].shape[0] for i in range(len(class_key))]
+    fig, ax = plt.subplots(
+        5,
+        len(class_key),
+        figsize=(12 * len(class_key), 20),
+        gridspec_kw={"width_ratios": ratios},
+        squeeze=False,
+    )
+    plt.figtext(0.1, 0.99,s='Version: '+version.__version__,figure=fig,fontdict={"size": 12})
+    width=0.8/len(models)
+    for i in range(len(class_key)):
+        index = np.arange(0, models[0].loc[class_key[i]].shape[0])
+        for j, frame in enumerate(models):
+            value_accuracy = frame.loc[class_key[i]].accuracy.values
+            value_recall = frame.loc[class_key[i]].recall.values
+            value_similarity = frame.loc[class_key[i]].similarity.values
+            value_top3=frame.loc[class_key[i]].top3_accuracy.values
+            # show accuracy
+            ax[0][i].bar(
+                x=index + j * width,
+                height=value_accuracy,
+                width=width,
+                align="center",
+                color=colors[j],
+                label=model_labels[j],
+            )
+            # show top3 accuracy if it exists
+            if not np.isnan(value_top3[0]):
+                ax[0][i].scatter(
+                    x=index + j * width,
+                    y=value_top3,
+                    marker="_",
+                    s=50,
+                    color=colors[j],
+                )
+                ax[0][i].vlines(
+                    x=index + j * width,
+                    ymin=0,
+                    ymax=value_top3,
+                    color=colors[j],
+                    linewidth=2,
+                )
+                for e, accuracy in enumerate(value_accuracy):
+                    ax[0][i].text(
+                        index[e] + j * width,
+                        value_top3[e] + 0.01,
+                        f"{accuracy:.3f}",
+                        ha="center",
+                        va="bottom",
+                        rotation="vertical",
+                        fontdict={"size": 7},
+                    )
+            else:
+                for e, accuracy in enumerate(value_accuracy):
+                    ax[0][i].text(
+                        index[e] + j * width,
+                        accuracy + 0.01,
+                        f"{accuracy:.3f}",
+                        ha="center",
+                        va="bottom",
+                        rotation="vertical",
+                        fontdict={"size": 7},
+                    )
+            # show recall
+            ax[1][i].bar(
+                x=index + j * width,
+                height=value_recall,
+                width=width,
+                align="center",
+                color=colors[j],
+            )
+            for e, recall in enumerate(value_recall):
+                ax[1][i].text(
+                    index[e] + j * width,
+                    recall+0.01,
+                    f"{recall:.3f}",
+                    ha="center",
+                    va="bottom",
+                    rotation="vertical",
+                    fontdict={"size": 7},
+                )
+
+        
+            
+            # show similarity scores
+            ax[2][i].bar(
+                x=index + j * width,
+                height=value_similarity,
+                width=width,
+                align="center",
+                color=colors[j],
+            )
+            for e, similarity in enumerate(value_similarity):
+                ax[2][i].text(
+                    index[e] + j * width,
+                    similarity+0.01,
+                    f"{similarity:.3f}",
+                    ha="center",
+                    va="bottom",
+                    rotation="vertical",
+                    fontdict={"size": 7},
+                )
+            # show accuracy-macro recall
+            difference = value_accuracy - value_recall
+            if np.amin(difference) < minimum:
+                minimum = np.amin(difference)
+            if np.amax(difference) > maximum:
+                maximum = np.amax(difference)
+            ax[3][i].bar(
+                x=index + j * width,
+                height=difference,
+                width=width,
+                align="center",
+                color=colors[j],
+            )
+            for e, dif in enumerate(difference):
+                if dif < 0:
+                    y_coord = 0
+                else:
+                    y_coord = dif
+                ax[3][i].text(
+                    index[e] + j * width,
+                    y_coord + 0.01,
+                    f"{dif:.3f}",
+                    ha="center",
+                    va="bottom",
+                    rotation="vertical",
+                    fontdict={"size": 7},
+                )
+
+        # Title, Label, Ticks and Ylim
+        ax[0][i].set_title(config.classes[i + 1], fontdict={"size": 22})
+        ax[1][i].set_title(config.classes[i + 1], fontdict={"size": 22})
+        ax[2][i].set_title(config.classes[i + 1], fontdict={"size": 22})
+        ax[3][i].set_title(config.classes[i + 1], fontdict={"size": 22})
+        ax[0][i].set_ylabel("Accuracy")
+        ax[1][i].set_ylabel("MacroRecall")
+        ax[2][i].set_ylabel("Similarity")
+        ax[3][i].set_ylabel("Accuracy-MacroRecall")
+        ax[0][i].set_xticks(index)
+        ax[0][i].set_xticklabels(
+            frame.loc[class_key[i]].name,
+            rotation=90,
+            fontdict={"horizontalalignment": "center", "size": 12},
+        )
+        ax[0][i].set_ylim(0, 1)
+        ax[0][i].set_xlim(-0.3, index[-1] + 1)
+        ax[1][i].set_xticks(index)
+        ax[1][i].set_xticklabels(
+            frame.loc[class_key[i]].name,
+            rotation=90,
+            fontdict={"horizontalalignment": "center", "size": 12},
+        )
+        ax[1][i].set_ylim(0, 1)
+        ax[1][i].set_xlim(-0.3, index[-1] + 1)
+        ax[2][i].set_xticks(index)
+        ax[2][i].set_xticklabels(
+            frame.loc[class_key[i]].name,
+            rotation=90,
+            fontdict={"horizontalalignment": "center", "size": 12},
+        )
+        ax[2][i].set_ylim(0, 1)
+        ax[2][i].set_xlim(-0.3, index[-1] + 1)
+        ax[3][i].set_xticks(index)
+        ax[3][i].set_xticklabels(
+            frame.loc[class_key[i]].name,
+            rotation=90,
+            fontdict={"horizontalalignment": "center", "size": 12},
+        )
+        ax[3][i].hlines(0, -0.3, index[-1] + 1, colors="k", lw=1)
+        ax[3][i].set_xlim(-0.3, index[-1] + 1)
+    # Make yaxis in difference plots equal to get a nice graph.
+    for x in range(len(ax[3])):
+        ax[3][x].set_ylim(minimum * 1.2, maximum * 1.2)
+    handles, labels = ax[0][0].get_legend_handles_labels()
+    ax[4][0].legend(handles, labels, loc=1, prop={"size": 12},ncol=len(labels))
+    ax[4][0].set_axis_off()
+    for x in range(1, len(class_key)):
+        ax[4][x].remove()
+    fig.tight_layout()
+
+    # Plot secondary structures
+    maximum = 0
+    minimum = 0
+    fig_secondary, ax_secondary = plt.subplots(2, 2, figsize=(24,12))
+    index = np.array([0, 1, 2, 3, 4])
+    for j, model in enumerate(model_scores):
+        accuracy, top_three, similarity, recall, precision = get_cath.score(
+            df, model, False, ignore_uncommon[j],
+        )
+        # show accuracy
+        ax_secondary[0][0].bar(
+            x=index + j * width,
+            height=accuracy,
+            width=width,
+            align="center",
+            color=colors[j],
+            label=model_labels[j],
+        )
+
+        # show recall
+        ax_secondary[0][1].bar(
+            x=index + j * width,
+            height=recall,
+            width=width,
+            align="center",
+            color=colors[j],
+            label=model_labels[j],
+        )
+        # show similarity score
+        ax_secondary[1][1].bar(
+            x=index + j * width,
+            height=similarity,
+            width=width,
+            align="center",
+            color=colors[j],
+            label=model_labels[j],
+        )
+        # show top three accuracy if exists
+        if not np.isnan(top_three[0]):
+            ax_secondary[0][0].scatter(
+                x=index + j * width, y=top_three, marker="_", s=50, color=colors[j]
+            )
+            ax_secondary[0][0].vlines(
+                x=index + j * width, ymin=0, ymax=top_three, color=colors[j], linewidth=2
+            )
+            # add accuracy values to the plot
+            for e, value in enumerate(accuracy):
+                ax_secondary[0][0].text(
+                    index[e] + j * width,
+                    top_three[e] + 0.01,
+                    f"{value:.3f}",
+                    ha="center",
+                    va="bottom",
+                    rotation="vertical",
+                    fontdict={"size": 12},
+                )
+        else:
+            for e, value in enumerate(accuracy):
+                ax_secondary[0][0].text(
+                    index[e] + j * width,
+                    value + 0.01,
+                    f"{value:.3f}",
+                    ha="center",
+                    va="bottom",
+                    rotation="vertical",
+                    fontdict={"size": 12},
+                )
+        #add other values to the plots       
+        for e, value in enumerate(recall):
+            ax_secondary[0][1].text(
+                index[e] + j * width,
+                value+0.01,
+                f"{value:.3f}",
+                ha="center",
+                va="bottom",
+                rotation="vertical",
+                fontdict={"size": 12},
+            )
+        for e, value in enumerate(similarity):
+            ax_secondary[1][1].text(
+                index[e] + j * width,
+                value+0.01,
+                f"{value:.3f}",
+                ha="center",
+                va="bottom",
+                rotation="vertical",
+                fontdict={"size": 12},
+            )
+        # show difference
+        difference = np.array(accuracy) - np.array(recall)
+        if np.amin(difference) < minimum:
+            minimum = np.amin(difference)
+        if np.amax(difference) > maximum:
+            maximum = np.amax(difference)
+        ax_secondary[1][0].bar(
+            x=index + j * width,
+            height=difference,
+            width=width,
+            align="center",
+            color=colors[j],
+        )
+        for e, dif in enumerate(difference):
+            if dif < 0:
+                y_coord = 0
+            else:
+                y_coord = dif
+            ax_secondary[1][0].text(
+                e + j * width,
+                y_coord + 0.01,
+                f"{dif:.3f}",
+                ha="center",
+                va="bottom",
+                rotation="vertical",
+                fontdict={"size": 12},
+            )
+        # Title, labels, ticks and limits
+        fig_secondary.suptitle("Secondary structure", fontdict={"size": 22})
+        ax_secondary[0][0].set_ylabel("Accuracy")
+        ax_secondary[0][0].set_xticks([0, 1, 2, 3, 4])
+        ax_secondary[0][0].set_xticklabels(
+            ["All structures", "Helices", "Sheets", "Structured loops", "Random"],
+            rotation=90,
+            fontdict={"horizontalalignment": "center", "size": 12},
+        )
+        ax_secondary[0][0].set_ylim(0, 1)
+        # leave some space from the sides to make it look nicer.
+        ax_secondary[0][0].set_xlim(-0.3, 5)
+
+        ax_secondary[0][1].set_ylabel("MacroRecall")
+        ax_secondary[0][1].set_xticks([0, 1, 2, 3, 4])
+        ax_secondary[0][1].set_xticklabels(
+            ["All structures", "Helices", "Sheets", "Structured loops", "Random"],
+            rotation=90,
+            fontdict={"horizontalalignment": "center", "size": 12},
+        )
+        ax_secondary[0][1].set_ylim(0, 1)
+        ax_secondary[0][1].set_xlim(-0.3, 5)
+
+        ax_secondary[1][1].set_ylabel("Similarity")
+        ax_secondary[1][1].set_xticks([0, 1, 2, 3, 4])
+        ax_secondary[1][1].set_xticklabels(
+            ["All structures", "Helices", "Sheets", "Structured loops", "Random"],
+            rotation=90,
+            fontdict={"horizontalalignment": "center", "size": 12},
+        )
+        ax_secondary[1][1].set_ylim(0, 1)
+        ax_secondary[1][1].set_xlim(-0.3, 5)
+
+        ax_secondary[1][0].set_ylabel("Accuracy-MacroRecall")
+        ax_secondary[1][0].set_xticks([0, 1, 2, 3, 4])
+        ax_secondary[1][0].set_xticklabels(
+            ["All structures", "Helices", "Sheets", "Structured loops", "Random"],
+            rotation=90,
+            fontdict={"horizontalalignment": "center", "size": 12},
+        )
+        ax_secondary[1][0].set_xlim(-0.3, 5)
+        ax_secondary[1][0].axhline(0, -0.3, index[-1] + 1, color="k", lw=1)
+        # make y axis in difference plots equal to get nicer graphs.
+        ax_secondary[1][0].set_ylim(ymax=maximum * 1.2)
+    fig_secondary.tight_layout()
+    
+    fig_corr,ax_corr=plt.subplots(figsize=(8.27,8.27))
+    #plot covarience between models
+    cov=pd.concat([x['accuracy'] for x in models], axis=1)
+    corr=cov.corr().to_numpy()
+    im = ax_corr.imshow(corr)
+    ax_corr.set_yticks(range(len(models)))
+    ax_corr.set_yticklabels(model_labels,)
+    ax_corr.set_xticks(range(len(models)))
+    ax_corr.set_xticklabels(model_labels,rotation = 90) 
+    fig_corr.colorbar(im, ax=ax_corr, fraction=0.046)
+    #add text
+    for i in range(len(models)):
+        for j in range(len(models)):
+            text = ax_corr.text(j, i, f"{corr[i, j]:.2f}",ha="center", va="center", color="w")
+    fig_corr.tight_layout()
+    pdf = matplotlib.backends.backend_pdf.PdfPages(location / "Comparison_summary.pdf")
+    
+    pdf.savefig(fig)
+    pdf.savefig(fig_secondary)
+    pdf.savefig(fig_corr)
+    pdf.close()
+    plt.close()
+    

data/dataset_visualization/crystal_structure_set.txt

@@ -0,0 +1,595 @@
+1xg0C
+3g3zA
+3rf0A
+4i5jA
+2ptrA
+3f0cA
+4a5uB
+2p57A
+2q0oC
+6er6A
+1h32A
+3e3vA
+3cxbA
+1dvoA
+5dicA
+2bnmA
+4pfoA
+2ebfX
+3giaA
+1a41A
+3cexA
+4ebbA
+3jrtA
+3wfdB
+4v1gA
+3qb9A
+3abhA
+3nvoA
+2o1kA
+5x56A
+2ra1A
+4adzA
+2p6vA
+3k4iA
+4lctA
+4adyA
+4zhbA
+4p6zG
+4nq0A
+3dadA
+2vq2A
+4dloA
+2of3A
+4y5jA
+2pm7A
+2hr2A
+3ro3A
+3bqoA
+3ut4A
+2yhcA
+4k6jA
+3iisM
+5agdA
+2fbaA
+3e7jA
+1v7wA
+3a0oA
+4wu0A
+4ozwA
+4cj0A
+1gxmA
+5m7yA
+4fnvA
+5gzkA
+4ayoA
+3wkgA
+3vsnA
+2jg0A
+4j5tA
+4ktpA
+4mqwA
+5lf2A
+5mriA
+5ol4B
+1bx7A
+3ca7A
+3tvjA
+3tbdA
+1uzkA
+5bq8A
+3klkA
+1b8kA
+1v6pA
+4hquA
+4k8wA
+6a2qA
+1lpbA
+3hrzB
+6fmeB
+2aydA
+2ra8A
+4fzqA
+3d4uB
+3wwlA
+2r01A
+1lslA
+3f3fC
+2q4zA
+2de6A
+3d9xA
+2hjeA
+3mcbB
+2y8nB
+3witA
+1ya5T
+2dyiA
+3kyfA
+2v76A
+2e12A
+1g3pA
+4o06A
+3fb9A
+2p38A
+1igqA
+4hhvA
+3teeA
+5j3tA
+5h3xA
+3zbdA
+5d7uA
+5zcjC
+5u1mA
+1wthD
+4rg1A
+1kt6A
+2ja9A
+1i4uA
+4i86A
+1o7iA
+1x8qA
+2ichA
+3dzmA
+3n91A
+1luzA
+4lqzA
+4i1kA
+5xlyB
+3a35A
+3tdqA
+4mxtA
+3wjtA
+3buuA
+3ksnA
+2w7qA
+2yzyA
+4z48A
+3bk5A
+4qa8A
+2byoA
+3bmzA
+4egdA
+4joxA
+3h6jA
+2bhuA
+1pmhX
+6ggrA
+4dqaA
+4v2bA
+4weeA
+2w07B
+4r9pA
+2r2cA
+2r0hA
+4aqoA
+4luqC
+3iagC
+1k5nA
+2ygnA
+3bwzA
+4fmrA
+1njhA
+4hi6A
+1pkhA
+1gp0A
+3q1nA
+2ag4A
+2v3iA
+3ty1A
+1gprA
+3aihA
+4c4aA
+1tulA
+4a02A
+4c08A
+4maiA
+1jovA
+3wmvA
+2fdbM
+1dqgA
+1xzzA
+6i18A
+4i4oA
+4efpA
+5yh4A
+3h6qA
+5bowA
+5vi4A
+2vxtI
+3vwcA
+4lo0C
+1sr4C
+2dpfA
+3dzwA
+3a0eA
+1xd5A
+4h3oA
+4tkcA
+5j76A
+3mezC
+4gc1A
+1b2pA
+4le7A
+4oitA
+6b0gE
+1z1yB
+1vmoA
+2gudA
+4r6rE
+5krpC
+5v6fA
+4pitA
+6flwA
+4ddnD
+3apaA
+5gvyA
+1c3mA
+4mq0A
+3wocA
+3aqgA
+3towA
+2qp2A
+1nykA
+2bmoA
+2gbwA
+1rfsA
+4aivA
+3gkeA
+2nwfA
+1jm1A
+2qpzA
+5cxmB
+3dqyA
+3d89A
+2b1xA
+4qdcA
+2q3wA
+3c7xA
+1genA
+1itvA
+3s18A
+4rt6B
+3cu9A
+3wasA
+6ms3B
+6frwA
+3k1uA
+5aycA
+5c0pA
+4n1iA
+3r4zA
+1tl2A
+4u6dA
+1oygA
+4qqsA
+3qz4A
+5a8cA
+4pvaA
+3kstA
+5flwA
+6gy5A
+1cruA
+1suuA
+3o4pA
+2p4oA
+4mzaA
+5gtqA
+3dr2A
+3dasA
+3g4eA
+2fp8A
+5hx0B
+1npeA
+1s1dA
+2zwaA
+3a72A
+2zb6A
+3scyA
+3b7fA
+3al9A
+3o4hA
+4pxwA
+4wk0A
+2w18A
+5em2A
+1sq9A
+1xipA
+4h5iA
+1jofA
+5ic7A
+5k19A
+6e1zA
+2z2nA
+6e4lA
+6fkwA
+6damA
+1flgA
+4cvbA
+4mh1A
+1z68A
+2z3zA
+4q1vA
+1xfdA
+5d7wA
+1kapP
+3laaA
+1p9hA
+3ultA
+3s6lA
+2xqhA
+4dt5A
+5m5zA
+5lw3A
+1k5cA
+1k4zA
+2ntpA
+3bh7B
+2j8kA
+2vfoA
+3n6zA
+1hf2A
+2x3hB
+1rmgA
+6mfkA
+1l0sA
+2xt2A
+5nzgA
+3kweA
+2w7zA
+1lktA
+3facA
+3pyiB
+2casA
+1gppA
+3maoA
+1ut7A
+1hxrA
+1t61A
+4qjvA
+3lywA
+3dalA
+5hqhA
+3u7zA
+3r90A
+1tp6A
+3s9xA
+2ex5A
+3gbyA
+5kvbA
+2cu3A
+1c1yB
+5f6rA
+4a6qA
+2w56A
+4lqbA
+4oobA
+3oajA
+3n8bA
+3jumA
+2prxA
+5b1rA
+1ewfA
+4m4dA
+2obdA
+6baqA
+1usuB
+3e8tA
+3aotA
+2rckA
+3l6iA
+3uv1A
+3bqwA
+5mprA
+1kkoA
+4cd8A
+1vd6A
+2g0wA
+4lanA
+3s83A
+2v3gA
+3fkrA
+4z0gA
+3sggA
+5zjbA
+2xfrA
+4g8tA
+5n6fA
+1muwA
+2qhqA
+3h35A
+3kluA
+3fn2A
+2od6A
+1kcfA
+3nlcA
+2zw2A
+4ftxA
+3u2aA
+2hiqA
+1xkpC
+6ih0A
+5c12A
+1w4rA
+3c0fB
+3nbmA
+2r6zA
+5hxdA
+1chdA
+3do8A
+3gohA
+1n0eA
+2q82A
+5kxhA
+3oqiA
+2x4lA
+3d3kA
+3l46A
+2fkcA
+5jphA
+3nytA
+3rhtA
+3dkrA
+2psbA
+1tc5A
+3vrdB
+2je3A
+3g5sA
+1jkeA
+4at0A
+1vi4A
+4u8pC
+4ntcA
+5ipyA
+5nakA
+4z24B
+4opcA
+5cdkA
+2b0aA
+4n2pA
+1j5uA
+1vzyB
+1vq0A
+4ipuA
+4dq9A
+4jtmA
+3gs9A
+3adyA
+3mi0A
+3ib7A
+3g91A
+1vr7A
+4zx2A
+1ds1A
+3zwfA
+1hq0A
+3hbcA
+3p8kA
+1wraA
+3t91A
+3c9fA
+2imhA
+1um0A
+5y0mA
+5u4hA
+3zh4A
+3swgA
+5ujsA
+3nvsA
+2o0bA
+2pqcA
+3slhA
+1rf6A
+4n3pA
+5bufA
+3rmtA
+4fqdA
+1ud9A
+1t6lA
+1rwzA
+3ifvA
+1iz5A
+3lx2A
+1u7bA
+5tupA
+5h0tA
+5v7mA
+3fdsC
+3aizA
+1b77A
+3p91A
+1dmlA
+3hslX
+2z0lA
+6nibA
+2jerA
+1xknA
+1zbrA
+3hvmA
+1jdwA
+5wpiA
+1g61A
+1h70A
+5m3qA
+1ynfA
+3wn4A
+1io0A
+4rcaB
+4fcgA
+4ecoA
+3wpcA
+4im6A
+4cnmA
+5hzlB
+4fs7A
+2xwtC
+3e4gA
+4wp6A
+5il7A
+1z7xW
+4u7lA
+6fg8A
+2wfhA
+2fy7A
+5wwdA
+1j3aA
+1omzA
+3emfA
+1xw3A
+3h4rA
+3essA
+1o22A
+4ktbA
+1jh6A
+3n08A
+5tsqA
+3e9vA
+4j7hA
+1i4jA
+2wnfA
+3v1aA
+3coqA
+2f60K
+4zgmA
+1i7wB
+6g6kA
+1pbyC
+1a92A
+3alrA
+2wjvD
+2a26A
+1devB
+4l0nA
+4ayaA
+3zxcA
+4pkfB
+2b1yA
+4dncD
+4jpnA
+4e18B
+3vepX
+3v4yB
+1xawA
+1ykhA
+2p64A
+6bscB
+2z3xA
+4uzzB
+3thfA
+1wq6A
+4ke2A
+4lhfA
+2v66B
+3lczA
+2h4oA
+4wjwA
+3kvpA
+3e56A
+3bk3C
+2ds5A
+3zoqB
+3nfgB
+4ksnA
+3ua0A
+3nrtA
+4a9aC
+6hikL

data/dataset_visualization/dataset_visualization.py

@@ -0,0 +1,94 @@
+from benchmark import get_cath
+from benchmark import config
+import pandas as pd
+import matplotlib.pyplot as plt
+from pathlib import Path 
+import numpy as np
+import seaborn as sns
+import matplotlib
+matplotlib.use('Agg')
+
+def format_secondary(df):
+    secondary=[[],[],[],[]]
+    for i,chain in df.iterrows():
+        for structure, residue in zip(list(chain.dssp), list(chain.sequence)):
+            if structure == "H" or structure == "I" or structure == "G":
+                secondary[0].append(residue)
+            elif structure == "E":
+                secondary[1].append(residue)
+            elif structure == "B" or structure == "T" or structure == "S":
+                secondary[2].append(residue)
+            else:
+                secondary[3].append(residue)
+    return secondary
+
+
+def describe_set(dataset,path_to_pdb):
+    plt.ioff()
+    df = get_cath.read_data("cath-domain-description-file.txt")
+    filtered_df = get_cath.filter_with_user_list(df, Path(dataset))
+    df_with_sequence = get_cath.append_sequence(filtered_df, Path(path_to_pdb))
+    #testing set has multiple chains from the same PDB, need to drop repeats for resolution plots.
+    resolution=df_with_sequence.drop_duplicates(subset=['PDB']).resolution.values
+    
+    fig,ax=plt.subplots(2,5,figsize=(25,10))
+    hist=np.histogram(resolution,bins=6,range=(0,3))
+    counts=hist[0]/len(resolution)
+    
+    ax[0][0].bar(range(len(counts)),counts)
+    ax[0][0].set_xlabel(r'Resolution, $\AA$')
+    ax[0][0].set_ylabel('Fraction of structures')
+    ax[0][0].set_xticks([0,1,2,3,4,5])
+    ax[0][0].set_xticklabels(['[0, 0.5)','[0.5, 1)','[1, 1.5)','[1.5, 2)','[2, 2.5)','[2.5, 3]'])
+    
+    colors = sns.color_palette()
+    arch=filtered_df.drop_duplicates(subset=['class'])['class'].values
+    grouped=filtered_df.groupby(by=['class','architecture']).count()
+    
+    previous_position=0
+    gs = ax[0, 0].get_gridspec()
+    for a in ax[0, 1:]:
+        a.remove()
+    ax_big = fig.add_subplot(gs[0, 1:])
+    for x in arch:
+        if x==1 or x==2 or x==3 or x==4:
+            architectures=grouped.loc[x]
+            ax_big.bar(range(previous_position,previous_position+architectures.shape[0]),architectures.PDB.values/filtered_df.shape[0],color=colors[x],label=config.classes[x])
+            previous_position+=architectures.shape[0]
+        #combine 4 and 6 for siplicity
+        if x==6:
+            architectures=grouped.loc[6]
+            ax_big.bar(range(previous_position,previous_position+architectures.shape[0]),architectures.PDB.values/filtered_df.shape[0],color=colors[4])
+        
+    
+    #get names
+    cls_arch=[f"{x[0]}.{x[1]}" for x in grouped.index]
+    names=[config.architectures[label] for label in cls_arch]
+    
+    ax_big.set_xticks(range(grouped.shape[0]))
+    ax_big.set_xticklabels(names, rotation=90, fontdict={"horizontalalignment": "center", "size": 12})
+    ax_big.set_ylabel('Fraction of structures')
+    ax_big.set_title('CATH architectures')
+    #make space for legend
+    ax_big.set_xlim(-0.8,grouped.shape[0]+4)
+    ax_big.legend()
+    
+    #get secondary structures, filtering with training set will get multiple CATH entries for the same chain.
+    secondary=format_secondary(df_with_sequence)
+    #plot residue distribution
+    ss_types=["Helices", "Sheets", "Structured loops", "Random"]
+    for x in range(len(secondary)):
+        ax[1][x].bar(config.acids,np.unique(secondary[x],return_counts=True)[1]/len(secondary[x]))
+        ax[1][x].set_ylabel('Fraction of structures')
+        ax[1][x].set_xlabel('Amino acids')
+        ax[1][x].set_title(ss_types[x])
+    #flatten the list
+    all_structures=[x for y in secondary for x in y]
+    ax[1][4].bar(config.acids,np.unique(all_structures,return_counts=True)[1]/len(all_structures))
+    ax[1][4].set_ylabel('Fraction of structures')
+    ax[1][4].set_xlabel('Amino acids')
+    ax[1][4].set_title('All structures')
+    plt.tight_layout()
+    plt.savefig(dataset+'.pdf')
+    
+describe_set("/home/s1706179/project/sequence-recovery-benchmark/nmr_benchmark.txt","/home/shared/datasets/pdb/")

data/dataset_visualization/nmr_benchmark.txt

@@ -0,0 +1,189 @@
+1hp8A
+1j2mA
+2kxeA
+2knjA
+2kp7A
+2k53A
+1wh6A
+2l2oA
+2lo0A
+2lznA
+1aq5A
+1pzqA
+2yufA
+2ksfA
+1ehsA
+1yycA
+2l81A
+1eq1A
+2dnxA
+2lhrA
+1zu2A
+2kc7A
+2katA
+2l0tB
+2l9bA
+2lniA
+2kckA
+2dcpA
+1rw2A
+2laiA
+2lckA
+1emnA
+1z6cA
+1lmjA
+1x6aA
+1bf9A
+2rtsA
+1apoA
+2jyeA
+1bi6H
+1a7iA
+2k2dA
+2mhgA
+2g2kA
+2rprA
+2l0zA
+1b8wA
+2dk7A
+2jr3A
+2jubA
+1dl6A
+2a7yA
+2kigA
+4csqA
+4a54A
+1yduA
+1kg1A
+2akkA
+2m9uA
+2kkuA
+1qw1A
+2mhdA
+2m9vA
+2k5dA
+2kz4A
+1j6qA
+2kd2A
+1oh1A
+2jn4A
+2lzjA
+1uapA
+2lgnA
+1wh0A
+2mctA
+2llgA
+2lv4A
+2joxA
+1so9A
+1exgA
+2jwyA
+1op4A
+2jooA
+5kqbA
+5kvpA
+2l2gA
+2llaA
+2l21A
+2kvaA
+2kijA
+1fmmS
+1irpA
+1hcdA
+2yugA
+2jz4A
+2jzaA
+2jo6A
+2jxyA
+2yuhA
+2kv1A
+2jnqA
+2kq1A
+2lwyA
+2kwbA
+2l3uA
+1h6qA
+2lcjA
+1jbiA
+2lvlA
+2m0aA
+2m7oA
+1wjnA
+2jovA
+2k0mA
+1xeeA
+2k89A
+2mjkA
+2kaaA
+2lyxA
+3zpmA
+2govA
+4aogA
+4bwhA
+2fmcA
+2kt9A
+2m3kA
+2mqdA
+1bbgA
+1nxiA
+2konA
+2m3dA
+2yreA
+2joeA
+1zwtA
+1adnA
+2mr6A
+2jzcA
+2k87A
+2kafA
+1x67A
+2dcqA
+2ov6A
+2kdpA
+2k4mA
+2ll3A
+2j8jA
+1hkyA
+1yxeA
+2k13X
+2hi6A
+2kl5A
+1jw3A
+2knqA
+2a02A
+2kknA
+2ellA
+2jqdA
+2krxA
+2memA
+1ksqA
+3zuaA
+1y6uA
+2j4mA
+2ejeA
+2lfcA
+1o8rA
+1wloA
+1y7jA
+1wfeA
+1gp8A
+2jryA
+1d6gA
+2m2fA
+2li8A
+2m13A
+1wvkA
+1hy9A
+2l2lA
+2kuyA
+2c55A
+2kwzA
+2lxwA
+2kesA
+1v65A
+2kj1A
+2rp4A
+2kktA
+2k4xA
+2lotA
+2conA

data/dataset_visualization/nmr_set.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebb9d071e4864e19f3726a06b54eed8170559eacc88c74f8bfb8c23351c1f357
+size 482121

data/examples/ProDcoNN.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bded015b2e600cab32b7cfaebf2bbdcf449200f233032a0ee46f4298efe76316
+size 56699674

data/examples/ProDcoNN.txt

@@ -0,0 +1,615 @@
+ignore_uncommon False
+include_pdbs
+##########
+1a41A 221
+1a92A 50
+1b2pA 119
+1b77A 228
+1b8kA 90
+1bx7A 51
+1c1yB 77
+1c3mA 145
+1chdA 198
+1cruA 448
+1devB 41
+1dmlA 267
+1dqgA 134
+1ds1A 323
+1dvoA 152
+1ejdA 419
+1ewfA 456
+1flgA 582
+1g3pA 192
+1g61A 225
+1genA 200
+1gp0A 133
+1gppA 217
+1gprA 158
+1gxmA 324
+1h32A 261
+1h70A 255
+1hf2A 196
+1hq0A 295
+1hxrA 107
+1i4jA 110
+1i4uA 181
+1i7wB 51
+1igqA 54
+1io0A 166
+1itvA 195
+1iz5A 240
+1j3aA 129
+1j5uA 127
+1jdwA 360
+1jh6A 181
+1jkeA 145
+1jm1A 202
+1jofA 365
+1jovA 269
+1k4zA 157
+1k5cA 333
+1k5nA 276
+1kapP 470
+1kcfA 240
+1kkoA 411
+1kt6A 175
+1l0sA 88
+1lktA 104
+1lpbA 85
+1lslA 113
+1luzA 85
+1muwA 386
+1n0eA 141
+1njhA 108
+1npeA 263
+1nykA 156
+1o22A 149
+1o7iA 115
+1omzA 253
+1ouwA 149
+1oygA 440
+1p2xA 159
+1p9hA 179
+1pbyC 79
+1pexA 192
+1pkhA 182
+1pmhX 183
+1rf6A 427
+1rfsA 127
+1rmgA 422
+1rwzA 244
+1s1dA 317
+1sq9A 378
+1sr4C 154
+1suuA 293
+1t61A 223
+1t6lA 249
+1tc5A 187
+1tl2A 235
+1tp6A 126
+1tulA 102
+1u7bA 251
+1ud9A 242
+1um0A 365
+1usuB 132
+1ut7A 147
+1uzkA 152
+1v6pA 62
+1v7wA 779
+1vd6A 218
+1vi4A 162
+1vmoA 163
+1vq0A 290
+1vr7A 120
+1vzyB 286
+1w4rA 174
+1wq6A 59
+1wraA 305
+1wthD 361
+1x8qA 184
+1xawA 107
+1xd5A 112
+1xfdA 723
+1xg0C 174
+1xipA 367
+1xknA 353
+1xkpC 126
+1xksA 374
+1xw3A 110
+1xzzA 216
+1ya5T 89
+1ykhA 95
+1ynfA 429
+1z1yB 175
+1z68A 719
+1z7xW 460
+1zbrA 339
+2a26A 48
+2ag4A 164
+2aydA 76
+2b0aA 186
+2b1xA 441
+2b1yA 101
+2bhuA 580
+2bmoA 437
+2bnmA 194
+2byoA 183
+2casA 548
+2cu3A 63
+2de6A 389
+2dpfA 111
+2ds5A 43
+2dyiA 162
+2e12A 93
+2ebfX 711
+2ex5A 207
+2f60K 60
+2fbaA 492
+2fdbM 149
+2fkcA 247
+2fp8A 302
+2fy7A 268
+2g0wA 275
+2gbwA 449
+2gudA 121
+2h4oA 62
+2hiqA 96
+2hjeA 210
+2hr2A 156
+2ichA 320
+2imhA 226
+2j8kA 181
+2ja9A 175
+2je3A 157
+2jerA 366
+2jg0A 507
+2ntpA 342
+2nwfA 141
+2o0bA 424
+2o1kA 43
+2obdA 472
+2od6A 110
+2of3A 266
+2p38A 155
+2p4oA 302
+2p57A 124
+2p64A 51
+2p6vA 97
+2pm7A 345
+2pqcA 445
+2prxA 114
+2psbA 290
+2ptrA 454
+2q0oC 86
+2q3wA 109
+2q4zA 307
+2q82A 114
+2qhqA 120
+2qp2A 498
+2qpzA 103
+2r01A 195
+2r0hA 160
+2r2cA 121
+2r6zA 225
+2ra1A 412
+2ra8A 351
+2rckA 221
+2v3gA 273
+2v3iA 434
+2v66B 111
+2v76A 99
+2vfoA 555
+2vq2A 220
+2vxtI 156
+2w07B 121
+2w18A 306
+2w56A 143
+2w7qA 192
+2w7zA 207
+2wfhA 181
+2wjvD 54
+2wnfA 272
+2x3hB 498
+2x4lA 298
+2xfrA 487
+2xqhA 258
+2xt2A 197
+2xwtC 234
+2y8nB 86
+2ygnA 146
+2yhcA 209
+2yzyA 163
+2z0lA 299
+2z2nA 293
+2z3xA 56
+2z3zA 651
+2zb6A 427
+2zw2A 85
+2zwaA 673
+3a0eA 110
+3a0oA 764
+3a35A 184
+3a72A 353
+3abhA 288
+3adyA 102
+3aihA 110
+3aizA 248
+3al9A 516
+3alrA 63
+3aotA 203
+3apaA 138
+3aqgA 133
+3ayjA 685
+3b7fA 368
+3bh7B 314
+3bk3C 67
+3bk5A 235
+3bmzA 185
+3bqoA 202
+3bqwA 347
+3buuA 224
+3bwzA 171
+3c0fB 85
+3c7xA 196
+3c9fA 531
+3ca7A 50
+3cexA 170
+3coqA 89
+3cu9A 314
+3cxbA 302
+3d3kA 233
+3d4uB 74
+3d89A 136
+3d9xA 114
+3dadA 324
+3dalA 179
+3dasA 334
+3dkrA 241
+3do8A 135
+3dqyA 106
+3dr2A 299
+3dzmA 208
+3dzwA 109
+3e3vA 154
+3e4gA 176
+3e56A 75
+3e7jA 743
+3e8tA 216
+3e9vA 120
+3emfA 113
+3essA 199
+3eunA 81
+3f0cA 193
+3f3fC 475
+3facA 109
+3fb9A 89
+3fdsC 249
+3fkrA 304
+3fn2A 97
+3g3zA 142
+3g4eA 297
+3g5sA 424
+3g91A 260
+3gbyA 127
+3giaA 433
+3gkeA 340
+3gohA 297
+3gs9A 326
+3gzxA 440
+3h35A 144
+3h4rA 219
+3h6jA 438
+3h6qA 168
+3hbcA 309
+3hrzB 233
+3hslX 287
+3hvmA 330
+3iagC 422
+3ib7A 295
+3ifvA 216
+3iisM 151
+3jrtA 166
+3jumA 157
+3k1uA 314
+3k4iA 202
+3klkA 1006
+3kluA 119
+3ksnA 177
+3kstA 291
+3kvpA 43
+3kw0A 190
+3kweA 166
+3kyfA 231
+3l46A 90
+3l6iA 171
+3laaA 169
+3lczA 53
+3lx2A 247
+3lywA 86
+3maoA 105
+3mcbB 58
+3mezC 110
+3mi0A 215
+3n08A 151
+3n6zA 339
+3n8bA 75
+3n91A 315
+3nbmA 104
+3nfgB 120
+3ng9A 520
+3nlcA 534
+3nrtA 93
+3nvoA 250
+3nvsA 426
+3nytA 359
+3o4hA 576
+3o4pA 314
+3oajA 310
+3oqiA 222
+3p8kA 268
+3p91A 245
+3pyiB 143
+3q1nA 294
+3qb9A 159
+3qz4A 306
+3r4zA 358
+3r90A 185
+3rf0A 199
+3rhtA 252
+3rmtA 432
+3ro3A 159
+3s18A 224
+3s6lA 155
+3s83A 256
+3s9xA 159
+3scyA 356
+3sggA 512
+3slhA 436
+3swgA 417
+3t91A 210
+3tbdA 331
+3tdqA 86
+3teeA 206
+3thfA 175
+3towA 152
+3tvjA 83
+3ty1A 384
+3u2aA 112
+3u7zA 97
+3ua0A 79
+3ultA 114
+3ut4A 128
+3uv1A 190
+3v1aA 48
+3v4yB 41
+3vcaA 398
+3vepX 46
+3vrdB 400
+3vsnA 632
+3vwcA 146
+3wasA 389
+3wfdB 449
+3witA 64
+3wjtA 178
+3wkgA 410
+3wmvA 150
+3wn4A 747
+3wocA 138
+3wpcA 747
+3wwlA 54
+3zbdA 110
+3zh4A 411
+3zoqB 48
+3zwfA 259
+3zxcA 71
+4a02A 166
+4a5uB 80
+4a6qA 143
+4a9aC 106
+4adyA 849
+4adzA 90
+4aivA 113
+4aqoA 86
+4at0A 483
+4ayaA 59
+4ayoA 434
+4c08A 325
+4c4aA 642
+4cd8A 313
+4cj0A 534
+4cnmA 283
+4cvbA 562
+4ddnD 154
+4dloA 351
+4dncD 42
+4dq9A 149
+4dqaA 349
+4dt5A 143
+4e18B 46
+4ebbA 450
+4ecoA 620
+4efpA 235
+4egdA 221
+4fcgA 296
+4fmrA 234
+4fnvA 659
+4fqdA 436
+4fs7A 383
+4ftxA 158
+4fzqA 79
+4g8tA 441
+4gc1A 275
+4h3oA 105
+4h5iA 344
+4hhvA 103
+4hi6A 138
+4hquA 95
+4i1kA 118
+4i4oA 146
+4i5jA 266
+4i86A 102
+4im6A 198
+4ipuA 137
+4j5tA 788
+4j7hA 446
+4joxA 118
+4jpnA 75
+4jtmA 81
+4jzzA 336
+4k6jA 497
+4k8wA 118
+4ke2A 196
+4ksnA 65
+4ktbA 160
+4ktpA 767
+4l0nA 51
+4lanA 370
+4lctA 318
+4le7A 254
+4lhfA 79
+4lo0C 144
+4lqbA 130
+4lqzA 131
+4luqC 123
+4m4dA 448
+4maiA 187
+4mh1A 509
+4mq0A 438
+4mqwA 88
+4mxtA 187
+4mzaA 432
+4n1iA 312
+4n2pA 143
+4n3pA 424
+4nq0A 254
+4ntcA 325
+4o06A 102
+4oitA 106
+4oobA 245
+4opcA 452
+4ozwA 334
+4p6zG 587
+4pfoA 755
+4pitA 140
+4pkfB 69
+4pvaA 328
+4pxwA 292
+4q1vA 707
+4qa8A 210
+4qdcA 369
+4qjvA 259
+4qqsA 312
+4r6rE 133
+4r9pA 210
+4rcaB 241
+4rg1A 286
+4rt6B 172
+4tkcA 118
+4u6dA 382
+4u7lA 455
+4u8pC 505
+4uzzB 65
+4v1gA 85
+4v2bA 106
+4weeA 135
+4wjwA 68
+4wk0A 449
+4wp6A 151
+4wu0A 360
+4y5jA 227
+4ya2H 222
+4ytbA 424
+4z0gA 384
+4z24B 649
+4z48A 240
+4zgmA 100
+4zhbA 104
+4zx2A 325
+5a8cA 299
+5agdA 333
+5aycA 386
+5b1rA 116
+5bowA 151
+5bq8A 104
+5bufA 445
+5c0pA 284
+5c12A 230
+5cdkA 181
+5cxmB 99
+5d7uA 53
+5d7wA 469
+5dicA 115
+5em2A 357
+5f6rA 173
+5flwA 302
+5gtqA 307
+5gvyA 145
+5gzkA 418
+5h0tA 248
+5h3xA 267
+5hqhA 96
+5hx0B 364
+5hxdA 237
+5hzlB 280
+5ic7A 340
+5il7A 440
+5ipyA 445
+5j3tA 126
+5j76A 109
+5jphA 142
+5k19A 376
+5krpC 150
+5kvbA 146
+5kxhA 350
+5lf2A 302
+5lw3A 381
+5m3qA 224
+5m5zA 755
+5m7yA 425
+5mprA 364
+5mriA 662
+5n6fA 365
+5nakA 452
+5nzgA 482
+5ol4B 122
+5tsqA 312
+5tupA 254
+5u1mA 105
+5u4hA 420
+5ujsA 417
+5v6fA 137
+5v7mA 255
+5vi4A 146
+5wpiA 364
+5wwdA 139
+5x56A 103
+5xlyB 121
+5y0mA 329
+5y5sQ 57
+5yh4A 179
+5zcjC 121
+5zjbA 232
+6a2qA 98
+6b0gE 154
+6baqA 196
+6bscB 48
+6damA 563
+6e1zA 307
+6e4lA 358
+6er6A 88
+6fg8A 188
+6fkwA 576
+6flwA 144
+6fmeB 505
+6frwA 411
+6g6kA 89
+6ggrA 168
+6gy5A 285
+6hcwA 502
+6hikL 40
+6i18A 484
+6ih0A 267
+6mfkA 210
+6ms3B 511
+6nibA 345
+6nkjA 412

data/examples/Rosetta.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89a8192da88f7f230068ba20d071d00397e2fe4808869e940ecb96ed8f22021c
+size 11926960

data/examples/Rosetta.txt

@@ -0,0 +1,600 @@
+ignore_uncommon False
+include_pdbs
+##########
+1xg0C 174
+3g3zA 142
+3rf0A 199
+4i5jA 266
+2ptrA 454
+3f0cA 193
+4a5uB 80
+2p57A 124
+2q0oC 86
+6er6A 88
+1h32A 261
+3e3vA 154
+3cxbA 302
+1dvoA 152
+5dicA 115
+2bnmA 194
+4pfoA 755
+2ebfX 711
+3giaA 433
+1a41A 221
+3cexA 170
+4ebbA 450
+3jrtA 166
+3wfdB 449
+4v1gA 85
+3qb9A 159
+3abhA 288
+3nvoA 250
+2o1kA 43
+5x56A 103
+2ra1A 412
+4adzA 90
+2p6vA 97
+3k4iA 202
+4lctA 318
+4adyA 849
+4zhbA 104
+4p6zG 587
+4nq0A 254
+3dadA 324
+2vq2A 220
+4dloA 351
+2of3A 266
+4y5jA 227
+2pm7A 345
+2hr2A 156
+3ro3A 159
+3bqoA 202
+3ut4A 128
+2yhcA 209
+4k6jA 497
+3iisM 151
+5agdA 333
+2fbaA 492
+3e7jA 743
+1v7wA 779
+3a0oA 764
+4wu0A 360
+4ozwA 334
+4cj0A 534
+1gxmA 324
+5m7yA 425
+4fnvA 659
+5gzkA 418
+4ayoA 434
+3wkgA 410
+3vsnA 632
+2jg0A 507
+4j5tA 788
+4ktpA 767
+4mqwA 88
+5lf2A 302
+5mriA 662
+5ol4B 122
+1bx7A 51
+3ca7A 50
+3tvjA 83
+3tbdA 331
+1uzkA 152
+5bq8A 104
+3klkA 1006
+1b8kA 90
+1v6pA 62
+4hquA 95
+4k8wA 118
+6a2qA 98
+1lpbA 85
+3hrzB 233
+6fmeB 505
+2aydA 76
+2ra8A 351
+4fzqA 79
+3d4uB 74
+3wwlA 54
+2r01A 195
+1lslA 113
+3f3fC 475
+2q4zA 307
+2de6A 389
+3d9xA 114
+2hjeA 210
+3mcbB 58
+2y8nB 86
+3witA 64
+1ya5T 89
+2dyiA 162
+3kyfA 231
+2v76A 99
+2e12A 93
+1g3pA 192
+4o06A 102
+3fb9A 89
+2p38A 155
+1igqA 54
+4hhvA 103
+3teeA 206
+5j3tA 126
+5h3xA 267
+3zbdA 110
+5d7uA 53
+5zcjC 121
+5u1mA 105
+1wthD 361
+4rg1A 286
+1kt6A 175
+2ja9A 175
+1i4uA 181
+4i86A 102
+1o7iA 115
+1x8qA 184
+2ichA 320
+3dzmA 208
+3n91A 315
+1luzA 85
+4lqzA 131
+4i1kA 118
+5xlyB 121
+3a35A 184
+3tdqA 86
+4mxtA 187
+3wjtA 178
+3buuA 224
+3ksnA 177
+2w7qA 192
+2yzyA 163
+4z48A 240
+3bk5A 235
+4qa8A 210
+2byoA 183
+3bmzA 185
+4egdA 221
+4joxA 118
+3h6jA 438
+2bhuA 580
+1pmhX 183
+6ggrA 168
+4dqaA 349
+4v2bA 106
+4weeA 135
+2w07B 121
+4r9pA 210
+2r2cA 121
+2r0hA 160
+4aqoA 86
+4luqC 123
+3iagC 422
+1k5nA 276
+2ygnA 146
+3bwzA 171
+4fmrA 234
+1njhA 108
+4hi6A 138
+1pkhA 182
+1gp0A 133
+3q1nA 294
+2ag4A 164
+2v3iA 434
+3ty1A 384
+1gprA 158
+3aihA 110
+4c4aA 642
+1tulA 102
+4a02A 166
+4c08A 325
+4maiA 187
+1jovA 269
+3wmvA 150
+2fdbM 149
+1dqgA 134
+1xzzA 216
+6i18A 484
+4i4oA 146
+4efpA 235
+5yh4A 179
+3h6qA 168
+5bowA 151
+5vi4A 146
+2vxtI 156
+3vwcA 146
+4lo0C 144
+1sr4C 154
+2dpfA 111
+3dzwA 109
+3a0eA 110
+1xd5A 112
+4h3oA 105
+4tkcA 118
+5j76A 109
+3mezC 110
+4gc1A 275
+1b2pA 119
+4le7A 254
+4oitA 106
+6b0gE 154
+1z1yB 175
+1vmoA 163
+2gudA 121
+4r6rE 133
+5krpC 150
+5v6fA 137
+4pitA 140
+6flwA 144
+4ddnD 154
+3apaA 138
+5gvyA 145
+1c3mA 145
+4mq0A 438
+3wocA 138
+3aqgA 133
+3towA 152
+2qp2A 498
+1nykA 156
+2bmoA 437
+2gbwA 449
+1rfsA 127
+4aivA 113
+3gkeA 340
+2nwfA 141
+1jm1A 202
+2qpzA 103
+5cxmB 99
+3dqyA 106
+3d89A 136
+2b1xA 441
+4qdcA 369
+2q3wA 109
+3c7xA 196
+1genA 200
+1itvA 195
+3s18A 224
+4rt6B 172
+3cu9A 314
+3wasA 389
+6ms3B 511
+6frwA 411
+3k1uA 314
+5aycA 386
+5c0pA 284
+4n1iA 312
+3r4zA 358
+1tl2A 235
+4u6dA 382
+1oygA 440
+4qqsA 312
+3qz4A 306
+5a8cA 299
+4pvaA 328
+3kstA 291
+5flwA 302
+6gy5A 285
+1cruA 448
+1suuA 293
+3o4pA 314
+2p4oA 302
+4mzaA 432
+5gtqA 307
+3dr2A 299
+3dasA 334
+3g4eA 297
+2fp8A 302
+5hx0B 364
+1npeA 263
+1s1dA 317
+2zwaA 673
+3a72A 353
+2zb6A 427
+3scyA 356
+3b7fA 368
+3al9A 516
+3o4hA 576
+4pxwA 292
+4wk0A 449
+2w18A 306
+5em2A 357
+1sq9A 378
+1xipA 367
+4h5iA 344
+1jofA 365
+5ic7A 340
+5k19A 376
+6e1zA 307
+2z2nA 293
+6e4lA 358
+6fkwA 576
+6damA 563
+1flgA 582
+4cvbA 562
+4mh1A 509
+1z68A 719
+2z3zA 651
+4q1vA 707
+1xfdA 723
+5d7wA 469
+1kapP 470
+3laaA 169
+1p9hA 179
+3ultA 114
+3s6lA 155
+2xqhA 258
+4dt5A 143
+5m5zA 755
+5lw3A 381
+1k5cA 333
+1k4zA 157
+2ntpA 342
+3bh7B 314
+2j8kA 181
+2vfoA 555
+3n6zA 339
+1hf2A 196
+2x3hB 498
+1rmgA 422
+6mfkA 210
+1l0sA 88
+2xt2A 197
+5nzgA 482
+3kweA 166
+2w7zA 207
+3ng9A 520
+1lktA 104
+3facA 109
+3pyiB 143
+2casA 548
+1gppA 217
+3maoA 105
+1ut7A 147
+1hxrA 107
+1t61A 223
+4qjvA 259
+3lywA 86
+3dalA 179
+5hqhA 96
+3u7zA 97
+3r90A 185
+1tp6A 126
+3s9xA 159
+2ex5A 207
+3gbyA 127
+5kvbA 146
+2cu3A 63
+1c1yB 77
+5f6rA 173
+4a6qA 143
+2w56A 143
+4lqbA 130
+4oobA 245
+3oajA 310
+3n8bA 75
+3jumA 157
+2prxA 114
+5b1rA 116
+1ewfA 456
+4m4dA 448
+2obdA 472
+6baqA 196
+1usuB 132
+3e8tA 216
+3aotA 203
+2rckA 221
+3l6iA 171
+3uv1A 190
+3bqwA 347
+5mprA 364
+1kkoA 411
+4cd8A 313
+1vd6A 218
+2g0wA 275
+4lanA 370
+3s83A 256
+2v3gA 273
+3fkrA 304
+4z0gA 384
+3sggA 512
+5zjbA 232
+2xfrA 487
+4g8tA 441
+5n6fA 365
+1muwA 386
+2qhqA 120
+3h35A 144
+3kluA 119
+3fn2A 97
+2od6A 110
+1kcfA 240
+3nlcA 534
+2zw2A 85
+4ftxA 158
+3u2aA 112
+2hiqA 96
+1xkpC 126
+6ih0A 267
+5c12A 230
+1w4rA 174
+3c0fB 85
+3nbmA 104
+2r6zA 225
+5hxdA 237
+1chdA 198
+3do8A 135
+3gohA 297
+1n0eA 141
+2q82A 114
+5kxhA 350
+3oqiA 222
+2x4lA 298
+3d3kA 233
+3l46A 90
+2fkcA 247
+5jphA 142
+3nytA 359
+3rhtA 252
+3dkrA 241
+2psbA 290
+1tc5A 187
+3vrdB 400
+2je3A 157
+3g5sA 424
+1jkeA 145
+4at0A 483
+1vi4A 162
+4u8pC 505
+4ntcA 325
+5ipyA 445
+5nakA 452
+4z24B 649
+4opcA 452
+5cdkA 181
+2b0aA 186
+4n2pA 143
+1j5uA 127
+1vzyB 286
+1vq0A 290
+4ipuA 137
+4dq9A 149
+4jtmA 81
+3gs9A 326
+3adyA 102
+3mi0A 215
+3ib7A 295
+3g91A 260
+1vr7A 120
+4zx2A 325
+1ds1A 323
+3zwfA 259
+1hq0A 295
+3hbcA 309
+3p8kA 268
+1wraA 305
+3t91A 210
+3c9fA 531
+2imhA 226
+1um0A 365
+5y0mA 329
+5u4hA 420
+1ejdA 419
+3zh4A 411
+3swgA 417
+5ujsA 417
+3nvsA 426
+2o0bA 424
+2pqcA 445
+3slhA 436
+1rf6A 427
+4n3pA 424
+5bufA 445
+3rmtA 432
+4fqdA 436
+1ud9A 242
+1t6lA 249
+1rwzA 244
+3ifvA 216
+1iz5A 240
+3lx2A 247
+1u7bA 251
+5tupA 254
+5h0tA 248
+5v7mA 255
+3fdsC 249
+3aizA 248
+1b77A 228
+3p91A 245
+1dmlA 267
+3hslX 287
+2z0lA 299
+6nibA 345
+2jerA 366
+1xknA 353
+1zbrA 339
+3hvmA 330
+1jdwA 360
+5wpiA 364
+1g61A 225
+1h70A 255
+5m3qA 224
+1ynfA 429
+3wn4A 747
+1io0A 166
+4rcaB 241
+4fcgA 296
+4ecoA 620
+3wpcA 747
+4im6A 198
+4cnmA 283
+5hzlB 280
+4fs7A 383
+2xwtC 234
+3e4gA 176
+4wp6A 151
+5il7A 440
+1z7xW 460
+4u7lA 455
+6fg8A 188
+2wfhA 181
+2fy7A 268
+5wwdA 139
+1j3aA 129
+1omzA 253
+3emfA 113
+1xw3A 110
+3h4rA 219
+3essA 199
+1o22A 149
+4ktbA 160
+1jh6A 181
+3n08A 151
+5tsqA 312
+3e9vA 120
+4j7hA 446
+1i4jA 110
+2wnfA 272
+3v1aA 48
+3coqA 89
+2f60K 60
+4zgmA 100
+1i7wB 51
+6g6kA 89
+1pbyC 79
+1a92A 50
+3alrA 63
+2wjvD 54
+2a26A 48
+1devB 41
+4l0nA 51
+4ayaA 59
+3zxcA 71
+4pkfB 69
+2b1yA 101
+4dncD 42
+4jpnA 75
+4e18B 46
+3vepX 46
+3v4yB 41
+1xawA 107
+1ykhA 95
+2p64A 51
+6bscB 48
+2z3xA 56
+4uzzB 65
+3thfA 175
+1wq6A 59
+4ke2A 196
+4lhfA 79
+2v66B 111
+3lczA 53
+2h4oA 62
+4wjwA 68
+3kvpA 43
+3e56A 75
+3bk3C 67
+2ds5A 43
+3zoqB 48
+3nfgB 120
+4ksnA 65
+3ua0A 79
+3nrtA 93
+4a9aC 106
+6hikL 40

data/examples/TIMED.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c53c97b8e7b72035ab53b4d4e22d1184ee2e75290dfd249c8ee2136f92efa24
+size 53412567

data/examples/TIMED.txt

@@ -0,0 +1,615 @@
+ignore_uncommon False
+include_pdbs 1a41
+##########
+1a41A 221
+1a92A 50
+1b2pA 119
+1b77A 228
+1b8kA 90
+1bx7A 51
+1c1yB 77
+1c3mA 145
+1chdA 198
+1cruA 448
+1devB 41
+1dmlA 267
+1dqgA 134
+1ds1A 323
+1dvoA 152
+1ejdA 419
+1ewfA 456
+1flgA 582
+1g3pA 192
+1g61A 225
+1genA 200
+1gp0A 133
+1gppA 217
+1gprA 158
+1gxmA 324
+1h32A 261
+1h70A 255
+1hf2A 196
+1hq0A 295
+1hxrA 107
+1i4jA 110
+1i4uA 181
+1i7wB 51
+1igqA 54
+1io0A 166
+1itvA 195
+1iz5A 240
+1j3aA 129
+1j5uA 127
+1jdwA 360
+1jh6A 181
+1jkeA 145
+1jm1A 202
+1jofA 365
+1jovA 269
+1k4zA 157
+1k5cA 333
+1k5nA 276
+1kapP 470
+1kcfA 240
+1kkoA 411
+1kt6A 175
+1l0sA 88
+1lktA 104
+1lpbA 85
+1lslA 113
+1luzA 85
+1muwA 386
+1n0eA 141
+1njhA 108
+1npeA 263
+1nykA 156
+1o22A 149
+1o7iA 115
+1omzA 253
+1ouwA 149
+1oygA 440
+1p2xA 159
+1p9hA 179
+1pbyC 79
+1pexA 192
+1pkhA 182
+1pmhX 183
+1rf6A 427
+1rfsA 127
+1rmgA 422
+1rwzA 244
+1s1dA 317
+1sq9A 378
+1sr4C 154
+1suuA 293
+1t61A 223
+1t6lA 249
+1tc5A 187
+1tl2A 235
+1tp6A 126
+1tulA 102
+1u7bA 251
+1ud9A 242
+1um0A 365
+1usuB 132
+1ut7A 147
+1uzkA 152
+1v6pA 62
+1v7wA 779
+1vd6A 218
+1vi4A 162
+1vmoA 163
+1vq0A 290
+1vr7A 120
+1vzyB 286
+1w4rA 174
+1wq6A 59
+1wraA 305
+1wthD 361
+1x8qA 184
+1xawA 107
+1xd5A 112
+1xfdA 723
+1xg0C 174
+1xipA 367
+1xknA 353
+1xkpC 126
+1xksA 374
+1xw3A 110
+1xzzA 216
+1ya5T 89
+1ykhA 95
+1ynfA 429
+1z1yB 175
+1z68A 719
+1z7xW 460
+1zbrA 339
+2a26A 48
+2ag4A 164
+2aydA 76
+2b0aA 186
+2b1xA 441
+2b1yA 101
+2bhuA 580
+2bmoA 437
+2bnmA 194
+2byoA 183
+2casA 548
+2cu3A 63
+2de6A 389
+2dpfA 111
+2ds5A 43
+2dyiA 162
+2e12A 93
+2ebfX 711
+2ex5A 207
+2f60K 60
+2fbaA 492
+2fdbM 149
+2fkcA 247
+2fp8A 302
+2fy7A 268
+2g0wA 275
+2gbwA 449
+2gudA 121
+2h4oA 62
+2hiqA 96
+2hjeA 210
+2hr2A 156
+2ichA 320
+2imhA 226
+2j8kA 181
+2ja9A 175
+2je3A 157
+2jerA 366
+2jg0A 507
+2ntpA 342
+2nwfA 141
+2o0bA 424
+2o1kA 43
+2obdA 472
+2od6A 110
+2of3A 266
+2p38A 155
+2p4oA 302
+2p57A 124
+2p64A 51
+2p6vA 97
+2pm7A 345
+2pqcA 445
+2prxA 114
+2psbA 290
+2ptrA 454
+2q0oC 86
+2q3wA 109
+2q4zA 307
+2q82A 114
+2qhqA 120
+2qp2A 498
+2qpzA 103
+2r01A 195
+2r0hA 160
+2r2cA 121
+2r6zA 225
+2ra1A 412
+2ra8A 351
+2rckA 221
+2v3gA 273
+2v3iA 434
+2v66B 111
+2v76A 99
+2vfoA 555
+2vq2A 220
+2vxtI 156
+2w07B 121
+2w18A 306
+2w56A 143
+2w7qA 192
+2w7zA 207
+2wfhA 181
+2wjvD 54
+2wnfA 272
+2x3hB 498
+2x4lA 298
+2xfrA 487
+2xqhA 258
+2xt2A 197
+2xwtC 234
+2y8nB 86
+2ygnA 146
+2yhcA 209
+2yzyA 163
+2z0lA 299
+2z2nA 293
+2z3xA 56
+2z3zA 651
+2zb6A 427
+2zw2A 85
+2zwaA 673
+3a0eA 110
+3a0oA 764
+3a35A 184
+3a72A 353
+3abhA 288
+3adyA 102
+3aihA 110
+3aizA 248
+3al9A 516
+3alrA 63
+3aotA 203
+3apaA 138
+3aqgA 133
+3ayjA 685
+3b7fA 368
+3bh7B 314
+3bk3C 67
+3bk5A 235
+3bmzA 185
+3bqoA 202
+3bqwA 347
+3buuA 224
+3bwzA 171
+3c0fB 85
+3c7xA 196
+3c9fA 531
+3ca7A 50
+3cexA 170
+3coqA 89
+3cu9A 314
+3cxbA 302
+3d3kA 233
+3d4uB 74
+3d89A 136
+3d9xA 114
+3dadA 324
+3dalA 179
+3dasA 334
+3dkrA 241
+3do8A 135
+3dqyA 106
+3dr2A 299
+3dzmA 208
+3dzwA 109
+3e3vA 154
+3e4gA 176
+3e56A 75
+3e7jA 743
+3e8tA 216
+3e9vA 120
+3emfA 113
+3essA 199
+3eunA 81
+3f0cA 193
+3f3fC 475
+3facA 109
+3fb9A 89
+3fdsC 249
+3fkrA 304
+3fn2A 97
+3g3zA 142
+3g4eA 297
+3g5sA 424
+3g91A 260
+3gbyA 127
+3giaA 433
+3gkeA 340
+3gohA 297
+3gs9A 326
+3gzxA 440
+3h35A 144
+3h4rA 219
+3h6jA 438
+3h6qA 168
+3hbcA 309
+3hrzB 233
+3hslX 287
+3hvmA 330
+3iagC 422
+3ib7A 295
+3ifvA 216
+3iisM 151
+3jrtA 166
+3jumA 157
+3k1uA 314
+3k4iA 202
+3klkA 1006
+3kluA 119
+3ksnA 177
+3kstA 291
+3kvpA 43
+3kw0A 190
+3kweA 166
+3kyfA 231
+3l46A 90
+3l6iA 171
+3laaA 169
+3lczA 53
+3lx2A 247
+3lywA 86
+3maoA 105
+3mcbB 58
+3mezC 110
+3mi0A 215
+3n08A 151
+3n6zA 339
+3n8bA 75
+3n91A 315
+3nbmA 104
+3nfgB 120
+3ng9A 520
+3nlcA 534
+3nrtA 93
+3nvoA 250
+3nvsA 426
+3nytA 359
+3o4hA 576
+3o4pA 314
+3oajA 310
+3oqiA 222
+3p8kA 268
+3p91A 245
+3pyiB 143
+3q1nA 294
+3qb9A 159
+3qz4A 306
+3r4zA 358
+3r90A 185
+3rf0A 199
+3rhtA 252
+3rmtA 432
+3ro3A 159
+3s18A 224
+3s6lA 155
+3s83A 256
+3s9xA 159
+3scyA 356
+3sggA 512
+3slhA 436
+3swgA 417
+3t91A 210
+3tbdA 331
+3tdqA 86
+3teeA 206
+3thfA 175
+3towA 152
+3tvjA 83
+3ty1A 384
+3u2aA 112
+3u7zA 97
+3ua0A 79
+3ultA 114
+3ut4A 128
+3uv1A 190
+3v1aA 48
+3v4yB 41
+3vcaA 398
+3vepX 46
+3vrdB 400
+3vsnA 632
+3vwcA 146
+3wasA 389
+3wfdB 449
+3witA 64
+3wjtA 178
+3wkgA 410
+3wmvA 150
+3wn4A 747
+3wocA 138
+3wpcA 747
+3wwlA 54
+3zbdA 110
+3zh4A 411
+3zoqB 48
+3zwfA 259
+3zxcA 71
+4a02A 166
+4a5uB 80
+4a6qA 143
+4a9aC 106
+4adyA 849
+4adzA 90
+4aivA 113
+4aqoA 86
+4at0A 483
+4ayaA 59
+4ayoA 434
+4c08A 325
+4c4aA 642
+4cd8A 313
+4cj0A 534
+4cnmA 283
+4cvbA 562
+4ddnD 154
+4dloA 351
+4dncD 42
+4dq9A 149
+4dqaA 349
+4dt5A 143
+4e18B 46
+4ebbA 450
+4ecoA 620
+4efpA 235
+4egdA 221
+4fcgA 296
+4fmrA 234
+4fnvA 659
+4fqdA 436
+4fs7A 383
+4ftxA 158
+4fzqA 79
+4g8tA 441
+4gc1A 275
+4h3oA 105
+4h5iA 344
+4hhvA 103
+4hi6A 138
+4hquA 95
+4i1kA 118
+4i4oA 146
+4i5jA 266
+4i86A 102
+4im6A 198
+4ipuA 137
+4j5tA 788
+4j7hA 446
+4joxA 118
+4jpnA 75
+4jtmA 81
+4jzzA 336
+4k6jA 497
+4k8wA 118
+4ke2A 196
+4ksnA 65
+4ktbA 160
+4ktpA 767
+4l0nA 51
+4lanA 370
+4lctA 318
+4le7A 254
+4lhfA 79
+4lo0C 144
+4lqbA 130
+4lqzA 131
+4luqC 123
+4m4dA 448
+4maiA 187
+4mh1A 509
+4mq0A 438
+4mqwA 88
+4mxtA 187
+4mzaA 432
+4n1iA 312
+4n2pA 143
+4n3pA 424
+4nq0A 254
+4ntcA 325
+4o06A 102
+4oitA 106
+4oobA 245
+4opcA 452
+4ozwA 334
+4p6zG 587
+4pfoA 755
+4pitA 140
+4pkfB 69
+4pvaA 328
+4pxwA 292
+4q1vA 707
+4qa8A 210
+4qdcA 369
+4qjvA 259
+4qqsA 312
+4r6rE 133
+4r9pA 210
+4rcaB 241
+4rg1A 286
+4rt6B 172
+4tkcA 118
+4u6dA 382
+4u7lA 455
+4u8pC 505
+4uzzB 65
+4v1gA 85
+4v2bA 106
+4weeA 135
+4wjwA 68
+4wk0A 449
+4wp6A 151
+4wu0A 360
+4y5jA 227
+4ya2H 222
+4ytbA 424
+4z0gA 384
+4z24B 649
+4z48A 240
+4zgmA 100
+4zhbA 104
+4zx2A 325
+5a8cA 299
+5agdA 333
+5aycA 386
+5b1rA 116
+5bowA 151
+5bq8A 104
+5bufA 445
+5c0pA 284
+5c12A 230
+5cdkA 181
+5cxmB 99
+5d7uA 53
+5d7wA 469
+5dicA 115
+5em2A 357
+5f6rA 173
+5flwA 302
+5gtqA 307
+5gvyA 145
+5gzkA 418
+5h0tA 248
+5h3xA 267
+5hqhA 96
+5hx0B 364
+5hxdA 237
+5hzlB 280
+5ic7A 340
+5il7A 440
+5ipyA 445
+5j3tA 126
+5j76A 109
+5jphA 142
+5k19A 376
+5krpC 150
+5kvbA 146
+5kxhA 350
+5lf2A 302
+5lw3A 381
+5m3qA 224
+5m5zA 755
+5m7yA 425
+5mprA 364
+5mriA 662
+5n6fA 365
+5nakA 452
+5nzgA 482
+5ol4B 122
+5tsqA 312
+5tupA 254
+5u1mA 105
+5u4hA 420
+5ujsA 417
+5v6fA 137
+5v7mA 255
+5vi4A 146
+5wpiA 364
+5wwdA 139
+5x56A 103
+5xlyB 121
+5y0mA 329
+5y5sQ 57
+5yh4A 179
+5zcjC 121
+5zjbA 232
+6a2qA 98
+6b0gE 154
+6baqA 196
+6bscB 48
+6damA 563
+6e1zA 307
+6e4lA 358
+6er6A 88
+6fg8A 188
+6fkwA 576
+6flwA 144
+6fmeB 505
+6frwA 411
+6g6kA 89
+6ggrA 168
+6gy5A 285
+6hcwA 502
+6hikL 40
+6i18A 484
+6ih0A 267
+6mfkA 210
+6ms3B 511
+6nibA 345
+6nkjA 412

data/examples/denseCPD.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd96d223f29ed356e1feed51f3651cade907a4bf3b4b20cfe1290a89fef8b330
+size 75520000

data/examples/denseCPD.txt

@@ -0,0 +1,609 @@
+ignore_uncommon False
+include_pdbs
+##########
+3kweA 166
+1devB 41
+1hf2A 196
+2p57A 124
+2qhqA 120
+2v3gA 273
+4h5iA 344
+4dt5A 143
+4wp6A 151
+3scyA 356
+2fdbM 149
+6flwA 144
+1tulA 102
+3thfA 175
+5zcjC 121
+2q0oC 86
+3nrtA 93
+3jumA 157
+4jpnA 75
+1chdA 198
+2r01A 195
+2e12A 93
+2yhcA 209
+5hqhA 96
+2casA 548
+4oitA 106
+4cj0A 534
+6e4lA 358
+3zwfA 259
+1i7wB 51
+4y5jA 227
+6nibA 345
+3coqA 89
+3tbdA 331
+2ebfX 711
+3n8bA 75
+1omzA 253
+3kyfA 231
+3fb9A 89
+3a0eA 110
+2b0aA 186
+1p2xA 159
+1x8qA 184
+2je3A 157
+2od6A 110
+3o4pA 314
+4k6jA 497
+4lqbA 130
+1ds1A 323
+1xd5A 112
+1k5cA 333
+2gudA 121
+1l0sA 88
+3ng9A 520
+4j7hA 446
+3cu9A 314
+4fqdA 436
+2f60K 60
+5hzlB 280
+5zjbA 232
+4p6zG 587
+2g0wA 275
+2dpfA 111
+2ptrA 454
+3zxcA 71
+3dkrA 241
+1b77A 228
+2w18A 306
+3h4rA 219
+4egdA 221
+3aihA 110
+4c4aA 642
+4ke2A 196
+3hbcA 309
+1gppA 217
+4mh1A 509
+3ua0A 79
+1t61A 223
+1sq9A 378
+3slhA 436
+3zbdA 110
+2w7zA 207
+4rcaB 241
+5ujsA 417
+1xksA 374
+4ebbA 450
+5y5sQ 0
+1kcfA 240
+3adyA 102
+1z7xW 460
+3h6jA 438
+3u7zA 97
+3oajA 310
+1oygA 440
+3hslX 287
+3a35A 184
+1o7iA 115
+1dqgA 134
+6ih0A 267
+5bq8A 104
+1h70A 255
+1dmlA 267
+5a8cA 299
+3e8tA 216
+6er6A 88
+5il7A 440
+2wjvD 54
+4uzzB 65
+3fkrA 304
+3gzxA 440
+2v66B 111
+1lslA 113
+5nakA 452
+3al9A 516
+2z0lA 299
+3dqyA 106
+4o06A 102
+2q4zA 307
+6fmeB 505
+1hq0A 295
+4qdcA 369
+3v4yB 41
+1flgA 582
+2nwfA 141
+1p9hA 179
+2qpzA 103
+3wasA 389
+4n2pA 143
+3o4hA 576
+4zhbA 104
+4lqzA 131
+5kxhA 350
+1k5nA 276
+4ozwA 334
+3g91A 260
+3lczA 53
+3tdqA 86
+3l46A 90
+5dicA 115
+3rhtA 252
+5nzgA 482
+3dadA 324
+2x4lA 298
+1z1yB 175
+5y0mA 329
+3wn4A 747
+3b7fA 368
+4wu0A 360
+4mq0A 438
+3wpcA 747
+1muwA 386
+3buuA 224
+5lw3A 381
+3lywA 86
+5aycA 386
+1vr7A 120
+5gvyA 145
+4fnvA 659
+5agdA 333
+3s18A 224
+1itvA 195
+3c9fA 531
+1lktA 104
+3ksnA 177
+4z48A 240
+4u7lA 455
+1sr4C 154
+5mprA 364
+1jofA 365
+1uzkA 152
+4adzA 90
+2z3xA 56
+1xfdA 723
+1jh6A 181
+1xzzA 216
+6g6kA 89
+1jm1A 202
+1o22A 149
+3d89A 136
+3sggA 512
+4a5uB 80
+3g3zA 142
+1s1dA 317
+1ejdA 419
+4u8pC 505
+3iagC 422
+2zwaA 673
+3pyiB 143
+4wk0A 449
+3rmtA 432
+3s9xA 159
+2vfoA 555
+3a0oA 764
+2bnmA 194
+3gs9A 326
+3eunA 81
+5flwA 302
+4hhvA 103
+4at0A 483
+5ipyA 445
+2bhuA 580
+1tp6A 126
+1kkoA 411
+2b1xA 441
+5d7wA 469
+4ecoA 620
+1jdwA 360
+3gbyA 127
+3oqiA 222
+1gxmA 324
+3kvpA 43
+4v2bA 106
+3nvsA 426
+2ra8A 351
+1k4zA 157
+3ut4A 128
+3q1nA 294
+2w7qA 192
+3teeA 206
+4qa8A 210
+3gohA 297
+4zgmA 100
+1wthD 361
+6gy5A 285
+4ayoA 434
+1u7bA 251
+2byoA 183
+3dzwA 109
+4cd8A 313
+6bscB 48
+1tc5A 187
+4n3pA 424
+4n1iA 312
+3k4iA 202
+3ib7A 295
+3facA 109
+1j3aA 129
+1xawA 107
+3jrtA 166
+3vepX 46
+4rg1A 286
+3lx2A 247
+2b1yA 101
+4cnmA 283
+1vq0A 290
+1ykhA 95
+3f3fC 475
+4i5jA 266
+3e3vA 154
+1rmgA 422
+2dyiA 162
+2qp2A 498
+3wmvA 150
+2xwtC 234
+1g3pA 192
+6frwA 411
+2cu3A 63
+5jphA 142
+5hx0B 364
+5tsqA 312
+4l0nA 51
+4i1kA 118
+2ja9A 175
+4weeA 135
+5u1mA 105
+2q3wA 109
+3d3kA 233
+4im6A 198
+4ntcA 325
+1t6lA 249
+1j5uA 127
+4luqC 123
+3d4uB 74
+5tupA 254
+4z24B 649
+3ca7A 50
+4tkcA 118
+3a72A 353
+3g4eA 297
+6fkwA 576
+5bowA 151
+4dloA 351
+3hvmA 330
+4ya2H 222
+4h3oA 105
+6damA 563
+2yzyA 163
+3gkeA 340
+5m7yA 425
+1ouwA 149
+4ipuA 137
+4k8wA 118
+2pm7A 345
+3bh7B 314
+2v76A 99
+3wocA 138
+4efpA 235
+4dncD 42
+4fcgA 296
+3tvjA 83
+4lctA 318
+3cexA 170
+5vi4A 146
+3v1aA 48
+4qqsA 312
+2prxA 114
+4le7A 254
+3aizA 248
+2o0bA 424
+4maiA 187
+2imhA 226
+4dq9A 149
+5ol4B 122
+3mcbB 58
+4g8tA 441
+2r6zA 225
+1xw3A 110
+4a9aC 106
+4mqwA 88
+2obdA 472
+3f0cA 193
+2ntpA 342
+5h3xA 267
+3nytA 359
+3mezC 110
+2de6A 389
+5j76A 109
+1c3mA 145
+3zh4A 411
+5b1rA 116
+1iz5A 240
+6i18A 484
+3wfdB 449
+3aotA 203
+3zoqB 48
+5yh4A 179
+5c0pA 284
+2z3zA 651
+6b0gE 154
+1vzyB 286
+5mriA 662
+1i4uA 181
+4fs7A 383
+1vmoA 163
+3e4gA 176
+4lanA 370
+5hxdA 237
+2fkcA 247
+3hrzB 233
+4m4dA 448
+1jkeA 145
+4ddnD 154
+2fp8A 302
+4dqaA 349
+3dzmA 208
+1genA 200
+3rf0A 199
+2q82A 114
+3abhA 288
+1bx7A 51
+3fn2A 97
+6baqA 196
+4nq0A 254
+2ygnA 146
+4lhfA 79
+3emfA 113
+2y8nB 86
+3r90A 185
+5kvbA 146
+3bqoA 202
+5d7uA 53
+4fmrA 234
+4fzqA 79
+5f6rA 173
+1pkhA 182
+1njhA 108
+2o1kA 43
+1ud9A 242
+1pbyC 79
+3nbmA 104
+3u2aA 112
+4a6qA 143
+5m5zA 755
+5ic7A 340
+3e56A 75
+6e1zA 307
+3witA 64
+4u6dA 382
+3alrA 63
+4i4oA 146
+2ichA 320
+4a02A 166
+3p91A 245
+2ag4A 164
+1kt6A 175
+1z68A 719
+4r6rE 133
+2zb6A 427
+2xt2A 197
+1xknA 353
+5u4hA 420
+5j3tA 126
+4pfoA 755
+3iisM 151
+1usuB 132
+1ewfA 456
+3fdsC 249
+3nlcA 534
+6mfkA 210
+2wfhA 181
+1rf6A 427
+4aqoA 86
+2p6vA 97
+2p4oA 302
+2r2cA 121
+5lf2A 302
+3kstA 291
+2of3A 266
+3vrdB 400
+1c1yB 77
+2h4oA 62
+3s83A 256
+3vwcA 146
+3bk3C 67
+2w07B 121
+1nykA 156
+4i86A 102
+1wq6A 59
+1a41A 221
+3r4zA 358
+5wpiA 364
+3kluA 119
+1vi4A 162
+4v1gA 85
+2aydA 76
+3apaA 138
+3do8A 135
+3e9vA 120
+6ggrA 168
+2a26A 48
+1w4rA 174
+3dalA 179
+3ifvA 216
+3cxbA 302
+3maoA 105
+5bufA 445
+3k1uA 314
+3aqgA 133
+2gbwA 449
+3bqwA 347
+6ms3B 511
+3qb9A 159
+4j5tA 788
+4ktbA 160
+4adyA 849
+1um0A 365
+1zbrA 339
+3l6iA 171
+2hjeA 210
+2p64A 51
+1lpbA 85
+6fg8A 188
+4wjwA 68
+4hquA 95
+1tl2A 235
+1hxrA 107
+2wnfA 272
+3bwzA 171
+1pmhX 183
+3vsnA 632
+1rwzA 244
+4pkfB 69
+4ayaA 59
+5n6fA 365
+1kapP 470
+4pitA 140
+3swgA 417
+2hiqA 96
+1b8kA 90
+4jtmA 81
+1v7wA 779
+5m3qA 224
+1io0A 166
+2r0hA 160
+6a2qA 98
+4zx2A 325
+3ultA 114
+2psbA 290
+2p38A 155
+1i4jA 110
+1ut7A 147
+4ftxA 158
+5x56A 103
+3n91A 315
+1b2pA 119
+2ex5A 207
+4lo0C 144
+3ty1A 384
+1xipA 367
+1gp0A 133
+5c12A 230
+5v6fA 137
+4joxA 118
+2rckA 221
+4cvbA 562
+4rt6B 172
+4gc1A 275
+1cruA 448
+5krpC 150
+1gprA 158
+5gtqA 307
+4hi6A 138
+4opcA 452
+3wwlA 54
+3qz4A 306
+1xkpC 126
+2fbaA 492
+2x3hB 498
+3n6zA 339
+3s6lA 155
+1vd6A 218
+3c0fB 85
+1pexA 192
+1rfsA 127
+3wjtA 178
+3dr2A 299
+4oobA 245
+2bmoA 437
+3c7xA 196
+3h35A 144
+5k19A 376
+4r9pA 210
+1dvoA 152
+1suuA 293
+3g5sA 424
+4ksnA 65
+5xlyB 121
+5em2A 357
+1ynfA 429
+4ktpA 767
+3wkgA 410
+5gzkA 418
+3klkA 1006
+2ds5A 43
+1h32A 261
+2v3iA 434
+1n0eA 141
+4qjvA 259
+5h0tA 248
+2zw2A 85
+5cdkA 181
+3uv1A 190
+4z0gA 384
+3nfgB 120
+4jzzA 336
+3nvoA 250
+2z2nA 293
+2hr2A 156
+4q1vA 707
+4mxtA 187
+1npeA 263
+1ya5T 89
+2xfrA 487
+2pqcA 445
+6hikL 40
+4e18B 46
+5v7mA 255
+3towA 152
+4pxwA 292
+3bmzA 185
+4c08A 325
+3n08A 151
+3mi0A 215
+1jovA 269
+1g61A 225
+2vxtI 156
+2ra1A 412
+3e7jA 743
+1igqA 54
+3ro3A 159
+5wwdA 139
+2xqhA 258
+4mzaA 432
+3t91A 210
+4aivA 113
+4pvaA 328
+1luzA 85
+3laaA 169
+3h6qA 168
+3d9xA 114
+3p8kA 268
+3essA 199
+1a92A 50
+1wraA 305
+3giaA 433
+2jerA 366
+2jg0A 507
+1v6pA 62
+3bk5A 235
+5cxmB 99
+2w56A 143
+3dasA 334
+2fy7A 268
+2j8kA 181
+1xg0C 174
+2vq2A 220

data/examples/evoEF2.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f18352b896da8d7361c3596e84b89a56d37004fe24640bf3bf408e226d25304d
+size 12122480

data/examples/evoEF2.txt

@@ -0,0 +1,609 @@
+ignore_uncommon False
+include_pdbs
+##########
+1p2xA 159
+1xg0C 174
+3g3zA 142
+3rf0A 199
+4i5jA 266
+2ptrA 454
+3f0cA 193
+4a5uB 80
+2p57A 124
+2q0oC 86
+6er6A 88
+1h32A 261
+3e3vA 154
+3cxbA 302
+1dvoA 152
+5dicA 115
+2bnmA 194
+4pfoA 755
+2ebfX 711
+3giaA 433
+1a41A 221
+3cexA 170
+4ebbA 450
+3jrtA 166
+3wfdB 449
+4v1gA 85
+3qb9A 159
+3abhA 288
+3nvoA 250
+2o1kA 43
+5x56A 103
+2ra1A 412
+4adzA 90
+2p6vA 97
+3k4iA 202
+4lctA 318
+4adyA 849
+4zhbA 104
+4p6zG 587
+4nq0A 254
+3dadA 324
+2vq2A 220
+4dloA 351
+2of3A 266
+4y5jA 227
+2pm7A 345
+2hr2A 156
+3ro3A 159
+3bqoA 202
+3ut4A 128
+2yhcA 209
+4k6jA 497
+3iisM 151
+5agdA 333
+2fbaA 492
+3e7jA 743
+1v7wA 779
+3a0oA 764
+4wu0A 360
+4ozwA 334
+4cj0A 534
+1gxmA 324
+5m7yA 425
+4fnvA 659
+5gzkA 418
+4ayoA 434
+3wkgA 410
+3vsnA 632
+2jg0A 507
+4j5tA 788
+4ktpA 767
+4mqwA 88
+5lf2A 302
+5mriA 662
+5ol4B 122
+1bx7A 51
+3ca7A 50
+3tvjA 83
+3tbdA 331
+1uzkA 152
+5bq8A 104
+3klkA 1006
+1b8kA 90
+1v6pA 62
+4hquA 95
+4k8wA 118
+6a2qA 98
+1lpbA 85
+3hrzB 233
+6fmeB 505
+2aydA 76
+2ra8A 351
+4fzqA 79
+3d4uB 74
+3wwlA 54
+2r01A 195
+1lslA 113
+3f3fC 475
+2q4zA 307
+2de6A 389
+3d9xA 114
+2hjeA 210
+3mcbB 58
+2y8nB 86
+3witA 64
+1ya5T 89
+2dyiA 162
+3kyfA 231
+2v76A 99
+2e12A 93
+1g3pA 192
+4o06A 102
+3fb9A 89
+2p38A 155
+1igqA 54
+4hhvA 103
+3teeA 206
+5j3tA 126
+5h3xA 267
+3zbdA 110
+5d7uA 53
+5zcjC 121
+5u1mA 105
+1wthD 361
+4rg1A 286
+1kt6A 175
+2ja9A 175
+1i4uA 181
+4i86A 102
+1o7iA 115
+1x8qA 184
+2ichA 320
+3dzmA 208
+3n91A 315
+1luzA 85
+4lqzA 131
+4i1kA 118
+5xlyB 121
+3a35A 184
+3tdqA 86
+4mxtA 187
+3wjtA 178
+3buuA 224
+3ksnA 177
+2w7qA 192
+2yzyA 163
+4z48A 240
+3bk5A 235
+4qa8A 210
+2byoA 183
+3bmzA 185
+4egdA 221
+4joxA 118
+3h6jA 438
+2bhuA 580
+1pmhX 183
+6ggrA 168
+4dqaA 349
+4v2bA 106
+4weeA 135
+2w07B 121
+4r9pA 210
+2r2cA 121
+2r0hA 160
+4aqoA 86
+4luqC 123
+3iagC 422
+1k5nA 276
+2ygnA 146
+3bwzA 171
+4fmrA 234
+1njhA 108
+4hi6A 138
+1pkhA 182
+1gp0A 133
+3q1nA 294
+2ag4A 164
+2v3iA 434
+3ty1A 384
+1gprA 158
+3aihA 110
+4c4aA 642
+1tulA 102
+4a02A 166
+4c08A 325
+4maiA 187
+1jovA 269
+3wmvA 150
+2fdbM 149
+1dqgA 134
+1xzzA 216
+6i18A 484
+4i4oA 146
+4efpA 235
+5yh4A 179
+3h6qA 168
+5bowA 151
+5vi4A 146
+2vxtI 156
+3vwcA 146
+4lo0C 144
+1sr4C 154
+2dpfA 111
+3dzwA 109
+3a0eA 110
+1xd5A 112
+4h3oA 105
+4tkcA 118
+5j76A 109
+3mezC 110
+4gc1A 275
+1b2pA 119
+4le7A 254
+4oitA 106
+6b0gE 154
+1z1yB 175
+1vmoA 163
+2gudA 121
+4r6rE 133
+5krpC 150
+5v6fA 137
+4pitA 140
+6flwA 144
+1ouwA 149
+4ddnD 154
+3apaA 138
+5gvyA 145
+1c3mA 145
+4mq0A 438
+3wocA 138
+3aqgA 133
+3towA 152
+2qp2A 498
+1nykA 156
+2bmoA 437
+2gbwA 449
+1rfsA 127
+4aivA 113
+3gkeA 340
+2nwfA 141
+1jm1A 202
+2qpzA 103
+5cxmB 99
+3gzxA 440
+3dqyA 106
+3d89A 136
+2b1xA 441
+4qdcA 369
+2q3wA 109
+3c7xA 196
+1genA 200
+1itvA 195
+1pexA 192
+3s18A 224
+4rt6B 172
+3cu9A 314
+3wasA 389
+6ms3B 511
+6frwA 411
+3k1uA 314
+5aycA 386
+5c0pA 284
+4n1iA 312
+3r4zA 358
+1tl2A 235
+4u6dA 382
+1oygA 440
+4qqsA 312
+3qz4A 306
+5a8cA 299
+4pvaA 328
+3kstA 291
+5flwA 302
+6gy5A 285
+1cruA 448
+1suuA 293
+3o4pA 314
+2p4oA 302
+4mzaA 432
+5gtqA 307
+3dr2A 299
+3dasA 334
+3g4eA 297
+2fp8A 302
+5hx0B 364
+1npeA 263
+1s1dA 317
+2zwaA 673
+3a72A 353
+2zb6A 427
+3scyA 356
+3b7fA 368
+3al9A 516
+3o4hA 576
+4pxwA 292
+4wk0A 449
+2w18A 306
+5em2A 357
+1sq9A 378
+1xipA 367
+4h5iA 344
+1jofA 365
+1xksA 374
+5ic7A 340
+5k19A 376
+6e1zA 307
+2z2nA 293
+6e4lA 358
+6fkwA 576
+6damA 563
+1flgA 582
+4cvbA 562
+4mh1A 509
+1z68A 719
+2z3zA 651
+4q1vA 707
+1xfdA 723
+5d7wA 469
+1kapP 470
+3laaA 169
+1p9hA 179
+3ultA 114
+3s6lA 155
+2xqhA 258
+4dt5A 143
+5m5zA 755
+5lw3A 381
+1k5cA 333
+1k4zA 157
+2ntpA 342
+3bh7B 314
+2j8kA 181
+2vfoA 555
+3n6zA 339
+1hf2A 196
+2x3hB 498
+1rmgA 422
+6mfkA 210
+1l0sA 88
+2xt2A 197
+5nzgA 482
+3kweA 166
+2w7zA 207
+3ng9A 520
+1lktA 104
+3facA 109
+3pyiB 143
+2casA 548
+1gppA 217
+3maoA 105
+1ut7A 147
+4jzzA 336
+1hxrA 107
+1t61A 223
+4qjvA 259
+3lywA 86
+3dalA 179
+5hqhA 96
+3u7zA 97
+3r90A 185
+1tp6A 126
+3s9xA 159
+2ex5A 207
+3gbyA 127
+5kvbA 146
+2cu3A 63
+1c1yB 77
+5f6rA 173
+4a6qA 143
+2w56A 143
+4lqbA 130
+4oobA 245
+3oajA 310
+3n8bA 75
+3jumA 157
+2prxA 114
+5b1rA 116
+1ewfA 456
+4m4dA 448
+2obdA 472
+6baqA 196
+1usuB 132
+3e8tA 216
+3aotA 203
+2rckA 221
+3l6iA 171
+3uv1A 190
+3bqwA 347
+5mprA 364
+1kkoA 411
+4cd8A 313
+1vd6A 218
+2g0wA 275
+4lanA 370
+3s83A 256
+2v3gA 273
+3fkrA 304
+4z0gA 384
+3sggA 512
+5zjbA 232
+2xfrA 487
+4g8tA 441
+5n6fA 365
+1muwA 386
+2qhqA 120
+3eunA 81
+3h35A 144
+3kluA 119
+3fn2A 97
+2od6A 110
+1kcfA 240
+3nlcA 534
+2zw2A 85
+4ftxA 158
+3u2aA 112
+2hiqA 96
+1xkpC 126
+6ih0A 267
+5c12A 230
+1w4rA 174
+3c0fB 85
+3nbmA 104
+2r6zA 225
+5hxdA 237
+1chdA 198
+3do8A 135
+3gohA 297
+1n0eA 141
+2q82A 114
+5kxhA 350
+3oqiA 222
+2x4lA 298
+3d3kA 233
+3l46A 90
+2fkcA 247
+5jphA 142
+3nytA 359
+3rhtA 252
+3dkrA 241
+2psbA 290
+1tc5A 187
+3vrdB 400
+2je3A 157
+3g5sA 424
+1jkeA 145
+4at0A 483
+1vi4A 162
+4u8pC 505
+4ntcA 325
+5ipyA 445
+5nakA 452
+4z24B 649
+4opcA 452
+5cdkA 181
+2b0aA 186
+4n2pA 143
+1j5uA 127
+1vzyB 286
+1vq0A 290
+4ipuA 137
+4dq9A 149
+4jtmA 81
+3gs9A 326
+3adyA 102
+3mi0A 215
+3ib7A 295
+3g91A 260
+1vr7A 120
+4zx2A 325
+1ds1A 323
+3zwfA 259
+1hq0A 295
+3hbcA 309
+3p8kA 268
+4ya2H 222
+1wraA 305
+3t91A 210
+3c9fA 531
+2imhA 226
+1um0A 365
+5y0mA 329
+5u4hA 420
+1ejdA 419
+3zh4A 411
+3swgA 417
+5ujsA 417
+3nvsA 426
+2o0bA 424
+2pqcA 445
+3slhA 436
+1rf6A 427
+4n3pA 424
+5bufA 445
+3rmtA 432
+4fqdA 436
+1ud9A 242
+1t6lA 249
+1rwzA 244
+3ifvA 216
+1iz5A 240
+3lx2A 247
+1u7bA 251
+5tupA 254
+5h0tA 248
+5v7mA 255
+3fdsC 249
+3aizA 248
+1b77A 228
+3p91A 245
+1dmlA 267
+3hslX 287
+2z0lA 299
+6nibA 345
+2jerA 366
+1xknA 353
+1zbrA 339
+3hvmA 330
+1jdwA 360
+5wpiA 364
+1g61A 225
+1h70A 255
+5m3qA 224
+1ynfA 429
+3wn4A 747
+1io0A 166
+4rcaB 241
+4fcgA 296
+4ecoA 620
+3wpcA 747
+4im6A 198
+4cnmA 283
+5hzlB 280
+4fs7A 383
+2xwtC 234
+3e4gA 176
+4wp6A 151
+5il7A 440
+1z7xW 460
+4u7lA 455
+6fg8A 188
+2wfhA 181
+2fy7A 268
+5wwdA 139
+1j3aA 129
+1omzA 253
+3emfA 113
+1xw3A 110
+3h4rA 219
+3essA 199
+1o22A 149
+4ktbA 160
+1jh6A 181
+3n08A 151
+5tsqA 312
+3e9vA 120
+4j7hA 446
+1i4jA 110
+2wnfA 272
+3v1aA 48
+3coqA 89
+2f60K 60
+4zgmA 100
+1i7wB 51
+6g6kA 89
+1pbyC 79
+1a92A 50
+3alrA 63
+2wjvD 54
+2a26A 48
+1devB 41
+4l0nA 51
+4ayaA 59
+3zxcA 71
+4pkfB 69
+2b1yA 101
+5y5sQ 491
+4dncD 42
+4jpnA 75
+4e18B 46
+3vepX 46
+3v4yB 41
+1xawA 107
+1ykhA 95
+2p64A 51
+6bscB 48
+2z3xA 56
+4uzzB 65
+3thfA 175
+1wq6A 59
+4ke2A 196
+4lhfA 79
+2v66B 111
+3lczA 53
+2h4oA 62
+4wjwA 68
+3kvpA 43
+3e56A 75
+3bk3C 67
+2ds5A 43
+3zoqB 48
+3nfgB 120
+4ksnA 65
+3ua0A 79
+3nrtA 93
+4a9aC 106
+6hikL 40

data/requirements.txt

@@ -0,0 +1,10 @@
+wget
+Cython
+numpy==1.19.5
+pandas==1.2.0
+AMPAL==1.4.0
+scikit-learn==0.24.1
+pathlib==1.0.1
+matplotlib==3.3.3
+click==7.1.2
+scipy==1.6.0

data/run_benchmark.py

@@ -0,0 +1,218 @@
+"Runs model comparison"
+
+from benchmark import visualization
+from benchmark import get_cath
+from pathlib import Path
+import click
+import os
+import sys
+
+
+def check_sets(dataset: Path, training_set: Path):
+    """Compares training and testing sets, warns if they overlap.
+    Parameters
+    ----------
+    dataset:Path
+        Path to .txt file with the dataset.
+    training_set:Path
+        Path to a file with the training set, can be PISCES, pdb code or pdb+chain.
+    """
+
+    with open(training_set) as file:
+        training_chains = [x.split()[0][:4].upper() for x in file.readlines()]
+        # check for pisces
+        if len(training_chains[0]) != 5:
+            training_chains = training_chains[1:]
+    # check only pdb codes, not chains
+    with open(dataset) as file:
+        testing_chains = [x.split()[0][:4].upper() for x in file.readlines()]
+
+    repeated_chains = set(testing_chains).intersection(set(training_chains))
+
+    if len(repeated_chains) > 0:
+        print(f"{len(repeated_chains)} chains are in both sets:")
+        for chain in repeated_chains:
+            print(chain)
+
+        print("\n")
+        print("Suggested benchmarking set:")
+        for chain in testing_chains:
+            if chain not in repeated_chains:
+                print(chain)
+        if click.confirm(
+            "Model evaluation might not be valid. Do you want to continue?"
+        ):
+            click.echo("Continuing!")
+        else:
+            exit()
+    else:
+        print("There is no overlap between sets.")
+
+
+@click.command("compare")
+@click.option(
+    "--dataset",
+    help="Path to .txt file with dataset list (PDB+chain, e.g., 1a2bA).",
+    type=click.Path(exists=True),
+    required=True,
+)
+@click.option(
+    "--training_set",
+    default=False,
+    help="Path to .txt file with the training set.",
+)
+@click.option(
+    "--path_to_pdb",
+    help="Path to the directory with PDB files.",
+    type=click.Path(exists=True),
+    required=True,
+)
+@click.option(
+    "--path_to_models",
+    help="Path to the directory with .csv prediction files.",
+    type=click.Path(exists=True),
+    required=True,
+)
+@click.option(
+    "--include",
+    help="Path to .txt file with a list of models to be included in comparison. If not provided, 8 models with the best accuracy are compared.",
+    type=click.Path(exists=True),
+)
+@click.option(
+    "--torsions",
+    is_flag=True,
+    help="Produces predicted and true Ramachandran plots for each model.",
+)
+def compare_models(
+    dataset: str,
+    path_to_pdb: str,
+    path_to_models: str,
+    training_set: str,
+    include: str = False,
+    torsions: bool = False,
+) -> None:
+    """Generates model summary and comparison plots.
+    \f
+    Parameters
+    ---------
+    dataset: str
+        Path to .txt file with dataset list (PDB+chain, e.g., 1a2bA).
+    path_to_pdb: str
+        Path to the directory with PDB files.
+    path_to_models: str.
+        Path to the directory with .csv prediction files.
+    include: str = False
+        Path to .txt file with a list of models to be included in comparison. If not provided, 8 models with the best accuracy are compared.
+    torsions: bool = False
+        Produces predicted and true Ramachandran plots for each model.
+    training_set:Path
+            Path to a file with the training set, can be PISCES, pdb code or pdb+chain.
+    """
+
+    # check training and testing sets
+    if training_set:
+        check_sets(Path(dataset), Path(training_set))
+    else:
+        # Warn and ask for confirmation to continue.
+        if click.confirm(
+            "Cannot compare training and testing sets. YOUR COMPARISON MIGHT NOT BE STATISTICALLY MEANINGFUL. Do you want to continue?"
+        ):
+            click.echo("Continuing!")
+        else:
+            exit
+
+    # get model labels to include in comparison
+    if include:
+        with open(include) as file:
+            models_to_include = [x.strip("\n") for x in file.readlines()]
+    df = get_cath.read_data(f"{Path(os.path.dirname(sys.argv[0]))/'cath-domain-description-file.txt'}")
+    filtered_df = get_cath.filter_with_user_list(df, dataset)
+    df_with_sequence = get_cath.append_sequence(
+        filtered_df, Path(path_to_pdb)
+    )
+
+    accuracy = []
+    # load predictions
+    list_of_models = {}
+    for name in os.listdir(path_to_models):
+        if name.split(".")[-1] == "csv":
+            path_to_file=Path(path_to_models)/name
+            with open(path_to_file.with_suffix('.txt')) as datasetmap:
+                model= get_cath.load_prediction_matrix(df_with_sequence, path_to_file.with_suffix('.txt'), path_to_file)
+                ignore_uncommon=eval(datasetmap.readline().split()[1])
+                pdbs=datasetmap.readline().split()
+                if len(pdbs)>1:
+                    #visualize accuracy and entropy on pdb files
+                    for protein in pdbs[1:]:
+                        visualization.show_accuracy(
+                            df_with_sequence,
+                            protein[:4],
+                            model,
+                            Path(path_to_models) / f"{name.strip('.csv')}_{protein}.pdb",
+                            Path(path_to_pdb),
+                            ignore_uncommon,
+                        )
+            list_of_models[name]=(model,ignore_uncommon)
+
+    for model in list_of_models:
+        # make model summary
+        visualization.make_model_summary(
+            df_with_sequence,
+            list_of_models[model][0],
+            str(Path(path_to_models) / model),
+            Path(path_to_pdb),
+            list_of_models[model][1],
+        )
+        # get overall accuracy
+        accuracy.append(
+            [
+                get_cath.score(
+                    df_with_sequence,
+                    list_of_models[model][0],
+                    ignore_uncommon=list_of_models[model][1],
+                )[0][0],
+                model,
+            ]
+        )
+        # make Ramachandran plots
+        if torsions:
+            sequence, prediction, _, angle = get_cath.format_angle_sequence(
+                df_with_sequence,
+                list_of_models[model][0],
+                Path(path_to_pdb),
+                ignore_uncommon=list_of_models[model][1],
+            )
+            visualization.ramachandran_plot(
+                sequence,
+                list(get_cath.most_likely_sequence(prediction)),
+                angle,
+                str(Path(path_to_models) / model),
+            )
+    accuracy = sorted(accuracy)
+    # pick 8 best models
+    filtered_models = [list_of_models[model[1]][0] for model in accuracy[-8:]]
+    ignore_list= [list_of_models[model[1]][1] for model in accuracy[-8:]]
+    filtered_labels = [model[1] for model in accuracy[-8:]]
+    # include specified models
+    if include:
+        if len(models_to_include) <= 8:
+            for index, model_name in enumerate(models_to_include):
+                if model_name not in filtered_labels:
+                    filtered_models[index] = list_of_models[model_name][0]
+                    ignore_list[index]=list_of_models[model_name][1]
+                    filtered_labels[index] = model_name
+        else:
+            raise ValueError(
+                "Too many models are give to plot, select no more than 8 models."
+            )
+
+    visualization.compare_model_accuracy(
+        df_with_sequence,
+        filtered_models,
+        filtered_labels,
+        Path(path_to_models),
+        ignore_list,
+    )
+    
+if __name__=="__main__":
+    compare_models()

data/run_predictions/make_empty_backbone_set.py

@@ -0,0 +1,124 @@
+import ampal
+import gzip
+from pathlib import Path
+import string
+import urllib
+
+def gly_resid(pdb: Path, chain:chr):
+    """Rewrite PDB,change all amino acids to Glycine.
+      Parameters
+      ----------
+      pdb: Path
+          Location of pdb file
+      chain: chr
+          Chain identifier, only this chain will be changed to polyG."""
+          
+    with open(pdb,'r') as file:
+        text=file.readlines()
+    for i,line in enumerate(text):
+        if line[21]==chain:
+            text[i]='ATOM  '+text[i][6:17]+'GLY'+text[i][20:]
+    with open(pdb,'w') as file:
+        file.writelines(text)
+
+def fetch_pdb(
+    pdb_code: str,
+    output_folder:Path,
+    pdb_request_url: str = "https://files.rcsb.org/download/" ,
+    is_pdb:bool=False,
+) -> None:
+    """
+    Downloads a specific pdb file into a specific folder.
+    Parameters
+    ----------
+    pdb_code : str
+        Code of the PDB file to be downloaded.
+    output_folder : Path
+        Output path to save the PDB file.
+    pdb_request_url : str
+        Base URL to download the PDB files.
+    is_pdb:bool=False
+        If True, get .pdb, else get biological assembly.
+    """
+    if is_pdb:
+        pdb_code_with_extension = f"{pdb_code[:4]}.pdb.gz"
+    else:
+        pdb_code_with_extension = f"{pdb_code[:4]}.pdb1.gz"
+    print(f'{pdb_code_with_extension} is missing and will be downloaded!')
+    urllib.request.urlretrieve(pdb_request_url + pdb_code_with_extension,filename=output_folder / pdb_code_with_extension)  
+      
+def polyglycine(dataset:Path,path_to_assemblies:Path,working_dir:Path,is_pdb:bool=False): 
+    """Converts protein chains into polyglycine chains.
+    Parameters
+    -----------
+    dataset:Path
+        Path to the dataset list containing PDB+chain info (e.g. 1a2bA)
+    path_to_assemblies:Path
+        Path to the directory with protein structure files; missing files will be downloaded automatically.
+    working_dir:Path
+        Path to the directory where polyglycine structures will be saved.
+    is_pdb:bool
+        If True, expects and downloads PDBs. If False, expects/downloads biological assembly."""
+                      
+    with open(dataset,'r') as file:
+        structures = [x.strip("\n") for x in file.readlines()]
+    if is_pdb:
+        suffix='.pdb.gz'
+    else:
+        suffix='.pdb1.gz'
+    for protein in structures:
+        if not Path(path_to_assemblies / (protein[:4]+suffix)).exists():
+            fetch_pdb(protein,path_to_assemblies,is_pdb=is_pdb)
+        
+        with gzip.open(path_to_assemblies / (protein[:4]+suffix)) as file:
+            assembly = ampal.load_pdb(file.read().decode(), path=False)
+            protein_chain=protein[-1]
+            if not is_pdb:
+                flag=0
+                # fuse all states of the assembly into one state.
+                empty_polymer = ampal.Assembly()
+                chain_id = []
+                for polymer in assembly:
+                    for chain in polymer:
+                        #remove side chains from the chain of interest
+                        #some assemblies have multiple chains with the same id, use flag to remove side chains only from the first one.
+                        if chain.id==protein_chain and flag==0:
+                            empty_polymer.append(chain.backbone)
+                            flag=1
+                        else:
+                            empty_polymer.append(chain)
+                        chain_id.append(chain.id)
+                # relabel chains to avoid repetition, remove ligands.
+            
+                str_list = string.ascii_uppercase.replace(protein_chain, "")
+                #assemblies such as viral capsids are longer than the alphabet
+                if len(empty_polymer)>=len(str_list):
+                     str_list=str_list*10
+                index = chain_id.index(protein_chain)
+                chain_id = list(str_list[: len(chain_id)])
+                chain_id[index] = protein_chain
+                empty_polymer.relabel_polymers(chain_id)
+                
+            else:
+                empty_polymer = ampal.Assembly()
+                #pick first state of NMR
+                if isinstance(assembly, ampal.assembly.AmpalContainer):
+                    assembly=assembly[0]
+                for chain in assembly:
+                    if chain.id==protein_chain:
+                        empty_polymer.append(chain.backbone)
+                    else:
+                        empty_polymer.append(chain)
+            # writing new pdb with AMPAL fixes most of the errors with EvoEF2 and Rosetta.
+            pdb_text = empty_polymer.make_pdb(alt_states=False, ligands=False)
+            with open((working_dir / protein[:4]).with_suffix(".pdb"), "w") as pdb_file:
+                pdb_file.write(pdb_text)
+            #change res ids to GLY for the backbone-only chain
+            gly_resid((working_dir / protein[:4]).with_suffix(".pdb"),protein_chain)
+            
+                
+if __name__=='__main__':
+    #biological assemblies of crystal structures
+    polyglycine(Path("/home/s1706179/Rosetta/data/set.txt"), Path("/home/s1706179/Rosetta/assemblies/"),Path("/home/s1706179/Rosetta/empty_backbones/"),False)
+    #first state of NMR structures
+    #polyglycine(Path("/home/s1706179/Rosetta/data/nmr_set.txt"), Path("/home/s1706179/Rosetta/nmr_structures/"),Path("/home/s1706179/Rosetta/empty_nmr_backbones/"),True)

data/run_predictions/run_EvoEF2/evo.sh

@@ -0,0 +1,16 @@
+#! /bin/sh
+#inputs:
+#$1 pdb name
+#$2 chain
+#$3 number of sequences to predict
+#$4 path to working dir
+#$5 Path to EvoEF2
+
+cd $4
+#get a specified number of sequences and print results to a .txt file
+for i in $(seq $3); do
+    $5 --command=ProteinDesign --ppint --design_chains=$2 --pdb=$1.pdb1 > /dev/null
+    cat $4/$1_bestseq.txt > $4/results/$1$2.txt
+    #remove working files to save space
+    rm $1*
+done

data/run_predictions/run_EvoEF2/evoef2_dataset.py

@@ -0,0 +1,177 @@
+"""Functions for making EvoEF2 predictions."""
+
+import ampal
+import gzip
+import glob
+import subprocess
+import multiprocessing
+import os
+from pathlib import Path
+from benchmark import config
+from sklearn.preprocessing import OneHotEncoder
+import warnings
+import numpy as np
+import pandas as pd
+
+def run_Evo2EF(
+    pdb: str, chain: str, number_of_runs: str, working_dir: Path, path_to_evoef2: Path
+) -> None:
+    """Runs a shell script to predict sequence with EvoEF2
+
+    Patameters
+    ----------
+    path: str
+        Path to PDB biological unit.
+    pdb: str
+        PDB code.
+    chain: str
+        Chain code.
+    number_of_runs: str
+       Number of sequences to be generated.
+    working_dir: str
+      Dir where to store temporary files and results.
+    path_to_EvoEF2: Path
+        Location of EvoEF2 executable.
+    """
+
+    print(f"Starting {pdb}{chain}.")
+
+    # evo.sh must be in the same directory as this file.
+    p = subprocess.Popen(
+        [
+            os.path.dirname(os.path.realpath(__file__)) + "/evo.sh",
+            pdb,
+            chain,
+            number_of_runs,
+            working_dir,
+            path_to_evoef2,
+        ]
+    )
+    p.wait()
+    print(f"{pdb}{chain} done.")
+
+
+def multi_Evo2EF(
+    df: pd.DataFrame,
+    number_of_runs: int,
+    working_dir: Path,
+    path_to_assemblies: Path,
+    path_to_evoef2: Path,
+    max_processes: int = 8,
+    nmr:bool = False,
+) -> None:
+    """Runs Evo2EF on all PDB chains in the DataFrame.
+
+    Parameters
+    ----------
+    df: pd.DataFrame
+        DataFrame with PDB and chain codes.
+    number_of_runs: int
+        Number of sequences to be generated for each PDB file.
+    max_processes: int = 8
+        Number of cores to use, default is 8.
+    working_dir: Path
+      Dir where to store temporary files and results.
+    path_to_assemblies: Path
+        Dir with biological assemblies.
+    path_to_EvoEF2: Path
+        Location of EvoEF2 executable.
+    nmr:bool=True
+
+    """
+
+    inputs = []
+    # remove duplicated chains
+    df = df.drop_duplicates(subset=["PDB", "chain"])
+
+    # check if working directory exists. Make one if doesn't exist.
+    if not working_dir.exists():
+        os.makedirs(working_dir)
+    if not (working_dir / "results/").exists():
+        os.makedirs(working_dir / "results/")
+
+    print(f"{df.shape[0]} structures will be predicted.")
+
+    for i, protein in df.iterrows():
+        if not nmr:
+            with gzip.open(
+                path_to_assemblies / protein.PDB[1:3] / f"{protein.PDB}.pdb1.gz"
+            ) as file:
+                assembly = ampal.load_pdb(file.read().decode(), path=False)
+            # fuse all states of the assembly into one state to avoid EvoEF2 errors.
+            empty_polymer = ampal.Assembly()
+            chain_id = []
+            for polymer in assembly:
+                for chain in polymer:
+                    empty_polymer.append(chain)
+                    chain_id.append(chain.id)
+            # relabel chains to avoid repetition, remove ligands.
+            str_list = string.ascii_uppercase.replace(protein.chain, "")
+            index = chain_id.index(protein.chain)
+            chain_id = list(str_list[: len(chain_id)])
+            chain_id[index] = protein.chain
+            empty_polymer.relabel_polymers(chain_id)
+            pdb_text = empty_polymer.make_pdb(alt_states=False, ligands=False)
+            # writing new pdb with AMPAL fixes most of the errors with EvoEF2.
+            with open((working_dir / protein.PDB).with_suffix(".pdb1"), "w") as pdb_file:
+                pdb_file.write(pdb_text)
+                
+        #pick first nmr structure        
+        else:
+            with gzip.open(
+                path_to_assemblies / protein.PDB[1:3] / f"pdb{protein.PDB}.ent.gz"
+            ) as file:
+                assembly = ampal.load_pdb(file.read().decode(), path=False)
+            pdb_text = assembly[0].make_pdb(alt_states=False)
+            # writing new pdb with AMPAL fixes most of the errors with EvoEF2.
+            with open((working_dir / protein.PDB).with_suffix(".pdb1"), "w") as pdb_file:
+                pdb_file.write(pdb_text)
+                
+        inputs.append(
+                (
+                    protein.PDB,
+                    protein.chain,
+                    str(number_of_runs),
+                    working_dir,
+                    path_to_evoef2,
+                )
+            )
+
+    with multiprocessing.Pool(max_processes) as P:
+        P.starmap(run_Evo2EF, inputs)
+        
+def seq_to_arr(working_dir: Path, user_list: Path, ignore_uncommon:bool=True):
+    """Produces prediction format compatible with the benchmarking tool.
+      working_dir: Path
+          Dir where EvoEF2 results are stored.
+      user_list: Path
+          Path to .txt file with protein chains to include in the benchmark"""
+          
+    with open(Path(user_list)) as file:
+        chains=[x.strip('\n') for x in file.readlines()]
+    predicted_sequences = []
+    path = Path(working_dir)
+    enc=OneHotEncoder(categories=[config.acids],sparse=False)
+    with open(path/'datasetmap.txt','w') as file:
+        file.write(f"ignore_uncommon {ignore_uncommon}\ninclude_pdbs\n##########\n")
+        for protein in chains:
+            prediction_path = path / "results"/f"{protein}.txt"
+            # check for empty and missing files
+            if prediction_path.exists() and os.path.getsize(prediction_path) > 0:
+                with open(prediction_path) as prediction:
+                    seq = prediction.readline().split()[0]
+                    if seq != "0":
+                        predicted_sequences+=list(seq)
+                       
+                        file.write(f"{protein} {len(seq)}\n")
+                    else:
+                        warnings.warn(
+                            f"EvoEF2: {protein} prediction does not exits, EvoEF2 returned 0."
+                        )
+            else:
+                warnings.warn(
+                    f"EvoEF2: {protein} prediction does not exits."
+                )
+    arr=enc.fit_transform(np.array(predicted_sequences).reshape(-1, 1))
+    pd.DataFrame(arr).to_csv(path/"evoEF2.csv", header=None, index=None)
+

data/run_predictions/run_EvoEF2/run_evoef2.py

@@ -0,0 +1,81 @@
+"Runs EvoEF2 predictions"
+
+import evoef2_dataset
+from benchmark import get_cath
+from pathlib import Path
+import click
+import os
+
+
+@click.command()
+@click.option(
+    "--dataset",
+    help="Path to .txt file with dataset list (PDB+chain, e.g., 1a2bA).",
+    type=click.Path(exists=True),
+    required=True,
+)
+@click.option(
+    "--path_to_assemblies",
+    help="Path to the directory with biological assemblies.",
+    type=click.Path(exists=True),
+    required=True,
+)
+@click.option(
+    "--working_dir",
+    help="Directory where to store results.",
+    type=click.Path(),
+    required=True,
+)
+@click.option(
+    "--path_to_evoef2",
+    help="Path to EvoEF2 executable.",
+    type=click.Path(exists=True),
+    required=True,
+)
+@click.option(
+    "--max_processes", help="Maximum number of cores to use", type=int, default=8
+)
+@click.option(
+    "--nmr", help="If true, also set path_to_assemblies to the directory with PDB files instead of biological assemblies.", type=bool, default=False
+)
+def run_evoEF2(
+    dataset: str,
+    working_dir: str,
+    path_to_evoef2: str,
+    max_processes: int,
+    path_to_assemblies: str,
+    nmr: bool=False,
+) -> None:
+    """Runs EvoEF2 sequence predictions on a specified set.
+    \f
+    Parameters
+    ---------
+    dataset: str
+        Path to .txt file with dataset list (PDB+chain, e.g., 1a2bA).
+    working_dir: str
+        Path to dir where to save temp files and results.
+    path_to_evoef2: str
+        Path to EvoEF2 executable.
+    max_processes: int
+        Maximum number of cores to use.
+    path_to_assemblies: str
+        Path to the directory with biological assemblies.
+    nmr: bool
+        If true, the code expects a PDB file with NMR states insted of biological assemblies.
+    """
+
+    df = get_cath.read_data("../cath-domain-description-file.txt")
+    filtered_df = get_cath.filter_with_user_list(df, dataset)
+
+    evoef2_dataset.multi_Evo2EF(
+        filtered_df,
+        1,
+        max_processes=max_processes,
+        working_dir=Path(working_dir),
+        path_to_evoef2=Path(path_to_evoef2),
+        path_to_assemblies=Path(path_to_assemblies),
+        nmr,
+    )
+
+if __name__=="__main__":
+    run_evoEF2()

data/run_predictions/run_Rosetta/fixbb.py

@@ -0,0 +1,217 @@
+import ampal
+import gzip
+import glob
+import subprocess
+import multiprocessing
+import os
+from pathlib import Path
+from sklearn.preprocessing import OneHotEncoder
+import warnings
+import numpy as np
+import pandas as pd
+import string
+import urllib
+from sklearn import metrics
+import numpy as np
+
+acids = [
+    "A",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "K",
+    "L",
+    "M",
+    "N",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "V",
+    "W",
+    "Y",
+]
+
+standard_residues = [
+    "ALA",
+    "ARG",
+    "ASN",
+    "ASP",
+    "CYS",
+    "GLU",
+    "GLN",
+    "GLY",
+    "HIS",
+    "ILE",
+    "LEU",
+    "LYS",
+    "MET",
+    "PHE",
+    "PRO",
+    "SER",
+    "THR",
+    "TRP",
+    "TYR",
+    "VAL",
+]
+
+
+def atom_to_hetatm(pdb: Path):
+    """Rosetta labels non-standard acids as ATOM instead of HETATM. This crashes AMPAL."""
+    with open(pdb, "r") as file:
+        text = file.readlines()
+    for i, line in enumerate(text):
+        if line[0:6].strip() == "ATOM" and line[17:20].strip() not in standard_residues:
+            text[i] = "HETATM" + text[i][6:]
+    with open(pdb, "w") as file:
+        file.writelines(text)
+
+
+def run_Rosetta(
+    pdb: str,
+    chain: str,
+    working_dir: Path,
+    path_to_Rosetta: Path,
+    path_to_assemblies: Path,
+) -> None:
+    """Runs Rosetta design with fixed backbone
+    Patameters
+    ----------
+    pdb: str
+        PDB code.
+    chain: str
+        Chain code.
+    working_dir: str
+      Dir where to store temporary files and results.
+    path_to_Rosetta: Path
+        Location of Rosetta executable.
+    path_to_assemblies:Path
+        Location of input PDB structures.
+    """
+
+    print(f"Starting {pdb}{chain}.")
+    # make resfile to predict only the specified chain, skip non-canonical residues
+    assembly = ampal.load_pdb(Path(path_to_assemblies / pdb).with_suffix(".pdb"))
+    with open(working_dir / ("resfile_" + pdb), "w") as file:
+        file.write("NATRO\nstart\n")
+        for i, x in enumerate(assembly[chain]):
+            file.write(f"{x.id} {chain} ALLAA\n")
+    p = subprocess.run(
+        f'{path_to_Rosetta} -s {Path(path_to_assemblies/pdb).with_suffix(".pdb")} -linmem_ig 10 -ignore_unrecognized_res -overwrite -resfile {working_dir/("resfile_"+pdb)} -out:path:all {working_dir/"results"}',
+        shell=True,
+    )
+    print(f"{pdb}{chain} done.")
+
+
+def seq_to_arr(working_dir: Path, user_list: Path, ignore_uncommon: bool = False):
+    """Produces prediction format compatible with the benchmarking tool.
+    working_dir: Path
+        Dir where Rosetta results are stored.
+    user_list: Path
+        Path to .txt file with protein chains to include in the benchmark"""
+
+    with open(Path(user_list)) as file:
+        chains = [x.strip("\n") for x in file.readlines()]
+    predicted_sequences = []
+    path = working_dir / "results"
+    enc = OneHotEncoder(categories=[acids], sparse=False)
+    with open(path / "datasetmap.txt", "w") as file:
+        file.write(f"ignore_uncommon {ignore_uncommon}\ninclude_pdbs\n##########\n")
+        for protein in chains:
+            prediction_path = path / f"{protein[:4]}_0001.pdb"
+            # check for empty and missing files
+            if prediction_path.exists():
+                try:
+                    assembly = ampal.load_pdb(prediction_path)
+                # fix malformed files
+                except ValueError:
+                    atom_to_hetatm(prediction_path)
+                    assembly = ampal.load_pdb(prediction_path)
+                # exclude positions with non-cannonical amino acids
+                if ignore_uncommon == True:
+                    # path to pdb has changed, change it manualy if you decide to use this option.
+                    temp_assembly = ampal.load_pdb(working_dir / f"{protein[:4]}.pdb")
+                    true_seq = temp_assembly[protein[-1]].sequence
+                    print(metrics.accuracy_score(list(seq), list(true_seq)))
+                    assert len(seq) == len(
+                        true_seq
+                    ), f"{protein} sequence lengths don't match"
+                    seq = "".join(
+                        [
+                            pred_ch
+                            for pred_ch, true_ch in zip(list(seq), list(true_seq))
+                            if true_ch != "X"
+                        ]
+                    )
+                    if seq.find("X") != -1:
+                        warnings.warn(
+                            f"Rosetta: {protein} has remaining non-canonical acids."
+                        )
+                seq = assembly[protein[-1]].sequence
+                predicted_sequences += list(seq)
+                file.write(f"{protein} {len(seq)}\n")
+            else:
+                warnings.warn(f"Rosetta: {protein} prediction does not exits.")
+    arr = enc.fit_transform(np.array(predicted_sequences).reshape(-1, 1))
+    pd.DataFrame(arr).to_csv(path / "rosetta.csv", header=None, index=None)
+
+
+def multi_Rosetta(
+    structures: list,
+    working_dir: Path,
+    path_to_assemblies: Path,
+    path_to_rosetta: Path,
+    max_processes: int = 8,
+) -> None:
+    """Runs Rosetta on all PDB chains in the DataFrame.
+    Parameters
+    ----------
+    structures:List
+        List with PDB and chain codes.
+    number_of_runs: int
+        Number of sequences to be generated for each PDB file.
+    max_processes: int = 8
+        Number of cores to use, default is 8.
+    working_dir: Path
+      Dir where to store temporary files and results.
+    path_to_assemblies: Path
+        Dir with biological assemblies.
+    path_to_rosetta: Path
+        Location of rosetta executable.
+    """
+
+    inputs = []
+
+    # check if working directory exists. Make one if doesn't exist.
+    if not working_dir.exists():
+        os.makedirs(working_dir)
+    if not (working_dir / "results").exists():
+        os.makedirs(working_dir / "results")
+    print(f"{len(structures)} structures will be predicted.")
+
+    for protein in structures:
+        inputs.append(
+            (
+                protein[:4],
+                protein[4],
+                working_dir,
+                path_to_rosetta,
+                path_to_assemblies,
+            )
+        )
+    with multiprocessing.Pool(max_processes) as P:
+        P.starmap(run_Rosetta, inputs)
+
+
+if __name__ == "__main__":
+    # seq_to_arr(Path('/home/s1706179/Rosetta/data_polyglycine/'),Path('/home/s1706179/Rosetta/data/set.txt'),False)
+    seq_to_arr(
+        Path("/home/s1706179/Rosetta/data_nmr_polyglycine/"),
+        Path("/home/s1706179/Rosetta/data/nmr_set.txt"),
+        False,
+    )

data/run_predictions/run_Rosetta/run_fixbb.py

@@ -0,0 +1,73 @@
+"Runs Rosetta predictions"
+
+import fixbb
+from pathlib import Path
+import click
+import os
+
+
+@click.command()
+@click.option(
+    "--dataset",
+    help="Path to .txt file with dataset list (PDB+chain, e.g., 1a2bA).",
+    type=click.Path(exists=True),
+    required=True,
+)
+@click.option(
+    "--path_to_assemblies",
+    help="Path to the directory with biological assemblies.",
+    type=click.Path(exists=True),
+    required=True,
+)
+@click.option(
+    "--working_dir",
+    help="Directory where to store results.",
+    type=click.Path(),
+    required=True,
+)
+@click.option(
+    "--path_to_rosetta",
+    help="Path to Rosetta executable.",
+    type=click.Path(exists=True),
+    required=True,
+)
+@click.option(
+    "--max_processes", help="Maximum number of cores to use", type=int, default=8
+)
+def run_rosetta(
+    dataset: str,
+    working_dir: str,
+    path_to_rosetta: str,
+    max_processes: int,
+    path_to_assemblies: str,
+) -> None:
+    """Runs EvoEF2 sequence predictions on a specified set.
+    \f
+    Parameters
+    ---------
+    dataset: str
+        Path to .txt file with dataset list (PDB+chain, e.g., 1a2bA).
+    working_dir: str
+        Path to dir where to save temp files and results.
+    path_to_rosetta: str
+        Path to Rosetta executable.
+    max_processes: int
+        Maximum number of cores to use.
+    path_to_assemblies: str
+        Path to the directory with biological assemblies.
+    nmr: bool
+        If true, the code expects a PDB file with NMR states insted of biological assemblies.
+    """
+    with open(dataset, "r") as file:
+        structures = [x.strip("\n") for x in file.readlines()]
+    fixbb.multi_Rosetta(
+        structures,
+        max_processes=max_processes,
+        working_dir=Path(working_dir),
+        path_to_rosetta=Path(path_to_rosetta),
+        path_to_assemblies=Path(path_to_assemblies),
+    )
+
+
+if __name__ == "__main__":
+    run_rosetta()

data/run_predictions/run_proteinsolver.ipynb

@@ -0,0 +1,201 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gzip\n",
+    "import heapq\n",
+    "import io\n",
+    "import json\n",
+    "import os\n",
+    "import shutil\n",
+    "import time\n",
+    "from pathlib import Path\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n",
+    "\n",
+    "import kmtools.sci_tools\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import proteinsolver\n",
+    "import pyarrow as pa\n",
+    "import pyarrow.parquet as pq\n",
+    "import torch\n",
+    "import torch_geometric\n",
+    "#from IPython.display import HTML, display\n",
+    "from kmbio import PDB\n",
+    "from torch_geometric.data import Batch\n",
+    "from tqdm.notebook import tqdm\n",
+    "from sklearn.preprocessing import OneHotEncoder\n",
+    "\n",
+    "acids = [\n",
+    "    \"A\",\n",
+    "    \"C\",\n",
+    "    \"D\",\n",
+    "    \"E\",\n",
+    "    \"F\",\n",
+    "    \"G\",\n",
+    "    \"H\",\n",
+    "    \"I\",\n",
+    "    \"K\",\n",
+    "    \"L\",\n",
+    "    \"M\",\n",
+    "    \"N\",\n",
+    "    \"P\",\n",
+    "    \"Q\",\n",
+    "    \"R\",\n",
+    "    \"S\",\n",
+    "    \"T\",\n",
+    "    \"V\",\n",
+    "    \"W\",\n",
+    "    \"Y\",\n",
+    "]\n",
+    "\n",
+    "@torch.no_grad()\n",
+    "def design_sequence(net, data, random_position=False, value_selection_strategy=\"map\", num_categories=None):\n",
+    "    assert value_selection_strategy in (\"map\", \"multinomial\", \"ref\")\n",
+    "\n",
+    "    if num_categories is None:\n",
+    "        num_categories = data.x.max().item()\n",
+    "\n",
+    "    if hasattr(data, \"batch\"):\n",
+    "        batch_size = data.batch.max().item() + 1\n",
+    "    else:\n",
+    "        print(\"Defaulting to batch size of one.\")\n",
+    "        batch_size = 1\n",
+    "\n",
+    "    if value_selection_strategy == \"ref\":\n",
+    "        x_ref = data.y if hasattr(data, \"y\") and data.y is not None else data.x\n",
+    "\n",
+    "    x = torch.ones_like(data.x) * num_categories\n",
+    "    x_proba = torch.zeros_like(x).to(torch.float)\n",
+    "    index_array_ref = torch.arange(x.size(0))\n",
+    "    mask_ref = x == num_categories\n",
+    "    while mask_ref.any():\n",
+    "        output = net(x, data.edge_index, data.edge_attr)\n",
+    "        output_proba_ref = torch.softmax(output, dim=1)\n",
+    "        output_proba_max_ref, _ = output_proba_ref.max(dim=1)\n",
+    "\n",
+    "        for i in range(batch_size):\n",
+    "            mask = mask_ref\n",
+    "            if batch_size > 1:\n",
+    "                mask = mask & (data.batch == i)\n",
+    "\n",
+    "            index_array = index_array_ref[mask]\n",
+    "            max_probas = output_proba_max_ref[mask]\n",
+    "\n",
+    "            if random_position:\n",
+    "                selected_residue_subindex = torch.randint(0, max_probas.size(0), (1,)).item()\n",
+    "                max_proba_index = index_array[selected_residue_subindex]\n",
+    "            else:\n",
+    "                selected_residue_subindex = max_probas.argmax().item()\n",
+    "                max_proba_index = index_array[selected_residue_subindex]\n",
+    "\n",
+    "            assert x[max_proba_index] == num_categories\n",
+    "            assert x_proba[max_proba_index] == 0\n",
+    "            category_probas = output_proba_ref[max_proba_index]\n",
+    "\n",
+    "            if value_selection_strategy == \"map\":\n",
+    "                chosen_category_proba, chosen_category = category_probas.max(dim=0)\n",
+    "            elif value_selection_strategy == \"multinomial\":\n",
+    "                chosen_category = torch.multinomial(category_probas, 1).item()\n",
+    "                chosen_category_proba = category_probas[chosen_category]\n",
+    "            else:\n",
+    "                assert value_selection_strategy == \"ref\"\n",
+    "                chosen_category = x_ref[max_proba_index]\n",
+    "                chosen_category_proba = category_probas[chosen_category]\n",
+    "\n",
+    "            assert chosen_category != num_categories\n",
+    "            x[max_proba_index] = chosen_category\n",
+    "            x_proba[max_proba_index] = chosen_category_proba\n",
+    "        mask_ref = x == num_categories\n",
+    "        del output, output_proba_ref, output_proba_max_ref\n",
+    "    return x.cpu(), x_proba.cpu()\n",
+    "    \n",
+    "\n",
+    "def run_ps(path_to_assemblies:Path, dataset_list:Path):\n",
+    "    #load the model\n",
+    "    state_file = '/home/s1706179/Proteinsolver/e53-s1952148-d93703104.state'\n",
+    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+    "    %run /home/s1706179/Proteinsolver/model.py\n",
+    "\n",
+    "    batch_size = 512\n",
+    "    num_features = 20\n",
+    "    adj_input_size = 2\n",
+    "    hidden_size = 128\n",
+    "    frac_present = 0.5\n",
+    "    frac_present_valid = frac_present\n",
+    "    info_size= 1024\n",
+    "\n",
+    "    net = Net(\n",
+    "        x_input_size=num_features + 1, adj_input_size=adj_input_size, hidden_size=hidden_size, output_size=num_features\n",
+    "    )\n",
+    "    net.load_state_dict(torch.load(state_file, map_location=device))\n",
+    "    net.eval()\n",
+    "    net = net.to(device)\n",
+    "    #run predictions\n",
+    "    with open(dataset_list,'r') as file:\n",
+    "        structures = [x.strip(\"\\n\") for x in file.readlines()]\n",
+    "    results={}\n",
+    "    for protein in structures:\n",
+    "        STRUCTURE_FILE = path_to_assemblies/(protein[:4]+'.pdb')\n",
+    "        chain_id=protein[-1]\n",
+    "        try:\n",
+    "            structure_all = PDB.load(STRUCTURE_FILE)\n",
+    "            structure = PDB.Structure(STRUCTURE_FILE.name + chain_id, structure_all[0].extract(chain_id))\n",
+    "            pdata = proteinsolver.utils.extract_seq_and_adj(structure, chain_id)\n",
+    "            data = proteinsolver.datasets.protein.row_to_data(pdata)\n",
+    "            data = proteinsolver.datasets.protein.transform_edge_attr(data)\n",
+    "            residues, residue_probas = design_sequence(\n",
+    "                net, data.to(device), random_position=False, value_selection_strategy=\"map\", num_categories=20\n",
+    "            )\n",
+    "            results[protein] = \"\".join(proteinsolver.utils.AMINO_ACIDS[i] for i in residues)\n",
+    "        except ValueError:\n",
+    "            continue\n",
+    "            \n",
+    "\n",
+    "    enc=OneHotEncoder(categories=[acids],sparse=False)\n",
+    "    predicted_sequences = []\n",
+    "    with open('/home/s1706179/Proteinsolver/proteinsolver_nmr.txt','w') as file:\n",
+    "        file.write(f\"ignore_uncommon False\\ninclude_pdbs\\n##########\\n\")\n",
+    "        for chain in results:\n",
+    "            predicted_sequences+=list(results[chain])\n",
+    "            file.write(f\"{chain} {len(results[chain])}\\n\")\n",
+    "    arr=enc.fit_transform(np.array(predicted_sequences).reshape(-1, 1))\n",
+    "    pd.DataFrame(arr).to_csv(\"/home/s1706179/Proteinsolver/proteinsolver_nmr.csv\", header=None, index=None)\n",
+    "    \n",
+    "run_ps(Path(\"/home/s1706179/Rosetta/empty_nmr_backbones/\"),Path(\"/home/s1706179/Rosetta/data/nmr_set.txt\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

data/setup.py

@@ -0,0 +1,12 @@
+from setuptools import find_packages, setup
+
+setup(
+    name="PDBench",
+    packages=find_packages(include=["benchmark"]),
+    version="0.1.0",
+    description="PDBench: software package for evaluating fixed-backbone sequence design algorithms",
+    author="Rokas Petrenas, Wells Wood Lab, University of Edinburgh",
+    license="MIT",
+    test_suite="test",
+    install_requires=['wheel','ampal','wget','numpy==1.19.5','pandas==1.2.0','scikit-learn==0.24.1','pathlib==1.0.1','matplotlib==3.3.3','click==7.1.2','scipy==1.6.0']
+)

data/test/run_test.py

@@ -0,0 +1,63 @@
+from benchmark import get_cath
+import numpy as np
+from pathlib import Path
+import os
+import sys
+
+
+location=Path(__file__).parent.resolve()
+PATH_TO_PDB=Path(sys.argv[1])
+assert (PATH_TO_PDB.exists()), 'PDB directory is missing!'
+
+def test_load_CATH():
+    """Tests basic benchmark functions - loading data, calculating metrics, ect."""
+    
+    cath_location = location.parents[0]/"cath-domain-description-file.txt"
+    cath_df = get_cath.read_data(cath_location)
+    new_df=get_cath.filter_with_user_list(cath_df,location/'test_set.txt')
+    # check shape
+    assert new_df.shape == (10, 8), "DataFrame shape is incorrect"
+    pdbs = get_cath.get_pdbs(new_df,1,20)
+    assert pdbs.shape == (1, 8), "Filtered shape is incorrect"
+
+    # check sequence, 1a41A02 fragment.
+    new_df = get_cath.append_sequence(new_df,PATH_TO_PDB)
+    fragment_sequence=new_df[new_df.PDB == "1a41"]
+    sequence=fragment_sequence.sequence.values[0]
+    start=fragment_sequence.start.values[0]
+    stop=fragment_sequence.stop.values[0]
+    assert (sequence[start:stop+1] == "IRIKDLRTYGVNYTFLYNFWTNVKSISPLPSPKKLIALTIKQTAEVVGHTPSISKRAYMATTILEMVKDKNFLDVVSKTTFDEFLSIVVDHVKS"
+    ), "Sequence assigned incorrectly"
+
+    #check sequence, 1cruA00 fragment
+    fragment_sequence=new_df[new_df.PDB == "1cru"]
+    sequence=fragment_sequence.sequence.values[0]
+    start=fragment_sequence.start.values[0]
+    stop=fragment_sequence.stop.values[0]
+    assert (sequence[start:stop+1] == "DVPLTPSQFAKAKSENFDKKVILSNLNKPHALLWGPDNQIWLTERATGKILRVNPESGSVKTVFQVPEIVNDADGQNGLLGFAFHPDFKNNPYIYISGTFKNPKSKELPNQTIIRRYTYNKSTDTLEKPVDLLAGLPSSKDHQSGRLVIGPDQKIYYTIGDQGRNQLAYLFLPNQAQHTPTQQELNGKDYHTYMGKVLRLNLDGSIPKDNPSFNGVVSHIYTLGHRNPQGLAFTPNGKLLQSEQGPNSDDEINLIVKGGNYGWPNVAGYKDDSGYAYANYSAAANKSIKDLAQNGVKVAAGVPVTKESEWTGKNFVPPLKTLYTVQDTYNYNDPTCGEMTYICWPTVAPSSAYVYKGGKKAITGWENTLLVPSLKRGVIFRIKLDPTYSTTYDDAVPMFKSNNRYRDVIASPDGNVLYVLTDTAGNVQKDDGSVTNTLENPGSLIKFT"
+    ), "Sequence assigned incorrectly"
+    
+    #load predictions
+    path_to_file=Path(location/'test_data.csv')
+    with open(path_to_file.with_suffix('.txt')) as datasetmap:
+      predictions = get_cath.load_prediction_matrix(new_df, path_to_file.with_suffix('.txt'), path_to_file)
+                
+    # check accuracy and recall
+    accuracy,recall=get_cath.score_each(new_df,predictions,by_fragment=True)
+    assert (
+        abs(accuracy[0] - 0.298) <= 0.001
+    ), "Sequence recovery calculated incorrectly"
+    
+    accuracy,recall=get_cath.score_each(new_df,predictions,by_fragment=True)
+    assert (
+        abs(recall[3] - 0.384) <= 0.001
+    ), "Macro-recall calculated incorrectly"
+    
+def test_command_line():
+    """Tests command line interface"""
+    os.system(f'python {location.parents[0]/"run_benchmark.py"} --dataset {location/"test_set.txt"} --path_to_pdb {PATH_TO_PDB} --path_to_models {location} --training_set {location/"trainingset.txt"}')
+    assert (Path(location/'test_data.csv.pdf').exists()), 'Failed to produce plots!'
+    assert (Path(location/'test_data_1a41.pdb').exists()), 'Failed to produce PDB with accuracy and entropy!'
+if __name__=='__main__':
+  test_load_CATH()
+  test_command_line()

data/test/test_data.txt

@@ -0,0 +1,13 @@
+ignore_uncommon False
+include_pdbs 1a41
+##########
+1a41A 221
+1a92A 50
+1b2pA 119
+1b77A 228
+1b8kA 90
+1bx7A 51
+1c1yB 77
+1c3mA 145
+1chdA 198
+1cruA 448

data/test/test_set.txt

@@ -0,0 +1,10 @@
+1a41A
+1a92A
+1b2pA
+1b77A
+1b8kA
+1bx7A
+1c1yB
+1c3mA
+1chdA
+1cruA