Natural_product_BGC_activity_prediction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Process antiSMASH files\n",
    "processes antiSMASH files stored in the antiSMASH_output directory to identify features. Feature lists and matrices are written to the feature_matrices folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from Bio import SeqIO\n",
    "\n",
    "def processCDSMotif(feature):\n",
    "    note_text = feature.qualifiers['note'][0]\n",
    "    if \"(\" not in note_text: #CDS name not formatted properly\n",
    "        return None\n",
    "    motif_name = note_text[0:note_text.index(\"(\")-1]\n",
    "    return motif_name\n",
    "\n",
    "def processCDS(feature):\n",
    "    smCOG_type = None\n",
    "    for note in feature.qualifiers[\"note\"]:\n",
    "        if \"smCOG\" in note:\n",
    "            if \":\" not in note or \"(\" not in note:\n",
    "                continue\n",
    "            smCOG_type = note[note.index(\":\")+2:note.index(\"(\")-1]\n",
    "    return smCOG_type\n",
    "\n",
    "def getFeatureList(feature_dictionary):\n",
    "    feature_list = []\n",
    "    feature_counts = {}\n",
    "    for cluster in feature_dictionary:\n",
    "        for feature in feature_dictionary[cluster]:\n",
    "            if feature not in feature_list:\n",
    "                feature_list.append(feature)\n",
    "                feature_counts[feature] = 0\n",
    "            feature_counts[feature] += 1\n",
    "                \n",
    "    return (feature_list, feature_counts)\n",
    "    \n",
    "def filterLowCounts(feature_list, feature_counts, threshold):\n",
    "    new_feature_list = []\n",
    "    for f in feature_list:\n",
    "        if feature_counts[f] >= threshold:\n",
    "            new_feature_list.append(f)\n",
    "    return new_feature_list\n",
    "\n",
    "#find name of PFAM domain if score is less than cutoff\n",
    "#default cutoff is 20\n",
    "def processPFAM(feature, score_cutoff=20):\n",
    "    score = float(feature.qualifiers[\"score\"][0])\n",
    "    if score <score_cutoff:\n",
    "        return None, None\n",
    "    domain_description = feature.qualifiers[\"description\"][0]\n",
    "    pfam_id = feature.qualifiers[\"db_xref\"][0]\n",
    "    pfam_id = pfam_id[pfam_id.find(\" \")+1:len(pfam_id)]\n",
    "    return domain_description, pfam_id\n",
    "\n",
    "#write a matrix with counts of features to a file and a list of the features to a separate file\n",
    "def writeFeatureMatrixFile(feature_dictionary, feature_list, output_dir, feature_name):\n",
    "    matrix_outfile = open(output_dir + feature_name + \".csv\", 'w')\n",
    "    list_outfile = open(output_dir + feature_name + \"_list.txt\",'w')\n",
    "    for cluster in feature_dictionary:\n",
    "        for feature in feature_list:\n",
    "            if feature in feature_dictionary[cluster]:\n",
    "                matrix_outfile.write(str(feature_dictionary[cluster][feature]) + \",\")\n",
    "            else:\n",
    "                matrix_outfile.write(\"0,\")\n",
    "        matrix_outfile.write(\"\\n\")\n",
    "    matrix_outfile.close()\n",
    "    \n",
    "    for f in feature_list:\n",
    "        list_outfile.write(f + \"\\n\")\n",
    "    list_outfile.close()\n",
    "        \n",
    "\n",
    "#parameters\n",
    "score_cutoff = 20 #PFAM HMM score to be counted\n",
    "feature_count_threshold = 5 #features must occur more then this number of times in dataset to be included\n",
    "\n",
    "input_dir = \"antiSMASH_output/\"\n",
    "output_dir = \"feature_matrices/\"\n",
    "CDS_motifs = {}\n",
    "CDS_motif_list = []\n",
    "CDS_total_counts = {}\n",
    "smCOGs = {}\n",
    "smCOG_list = []\n",
    "smCOG_total_counts = {}\n",
    "pfam_list = []\n",
    "pfam_id_list = []\n",
    "pfam_counts = {}\n",
    "pfam_total_counts = {}\n",
    "pks_nrp_subtypes = {}\n",
    "pk_monomers_signature = {}\n",
    "pk_monomers_minowa = {}\n",
    "pk_monomers_consensus = {}\n",
    "nrp_monomers_stachelhaus = {}\n",
    "nrp_monomers_nrps_predictor = {}\n",
    "nrp_monomers_pHMM = {}\n",
    "nrp_monomers_predicat = {}\n",
    "nrp_monomers_sandpuma = {}\n",
    "\n",
    "for f in sorted(os.listdir(input_dir),key=str.lower):\n",
    "    if \".gbk\" not in f or \".gb\" not in f: #skip files that do not have genbank extension\n",
    "        continue\n",
    "    record = SeqIO.read(open(input_dir + f, 'r'),\"genbank\")\n",
    "    features = record.features\n",
    "    cluster_name = f[0:f.index(\".\")]\n",
    "    CDS_motifs[cluster_name] = {}\n",
    "    smCOGs[cluster_name] = {}\n",
    "    pfam_counts[cluster_name] = {}\n",
    "    pks_nrp_subtypes[cluster_name] = {}\n",
    "    pk_monomers_signature[cluster_name] = {}\n",
    "    pk_monomers_minowa[cluster_name] = {}\n",
    "    pk_monomers_consensus[cluster_name] = {}\n",
    "    nrp_monomers_stachelhaus[cluster_name] = {}\n",
    "    nrp_monomers_nrps_predictor[cluster_name] = {}\n",
    "    nrp_monomers_pHMM[cluster_name] = {}\n",
    "    nrp_monomers_predicat[cluster_name] = {}\n",
    "    nrp_monomers_sandpuma[cluster_name] = {}\n",
    "    \n",
    "    subtype = \"\"\n",
    "    pks_signature = \"\"\n",
    "    minowa = \"\"\n",
    "    consensus = \"\"\n",
    "    stachelhaus = \"\"\n",
    "    nrpspredictor = \"\"\n",
    "    pHMM = \"\"\n",
    "    predicat = \"\"\n",
    "    sandpuma = \"\"\n",
    "    \n",
    "    for feature in features:\n",
    "        subtype = \"\"\n",
    "        pks_signature = \"\"\n",
    "        minowa = \"\"\n",
    "        consensus = \"\"\n",
    "        stachelhaus = \"\"\n",
    "        nrpspredictor = \"\"\n",
    "        pHMM = \"\"\n",
    "        predicat = \"\"\n",
    "        sandpuma = \"\"\n",
    "        \n",
    "        #process CDS motifs\n",
    "        if feature.type == \"CDS_motif\":\n",
    "            motif_name = processCDSMotif(feature)\n",
    "            if motif_name == None:\n",
    "                continue\n",
    "            if motif_name not in CDS_motif_list:\n",
    "                CDS_motif_list.append(motif_name)\n",
    "                CDS_total_counts[motif_name] =0\n",
    "            if motif_name not in CDS_motifs[cluster_name]:\n",
    "                CDS_motifs[cluster_name][motif_name] = 0\n",
    "            CDS_motifs[cluster_name][motif_name] += 1\n",
    "            CDS_total_counts [motif_name] += 1\n",
    "        \n",
    "        #process smCOG annotations, listed as CDS feature\n",
    "        #also process nrp and pk monomer predictions\n",
    "        elif feature.type == \"CDS\":\n",
    "            if \"note\" in feature.qualifiers:\n",
    "                #process smCOG features\n",
    "                smCOG_type = processCDS(feature)\n",
    "                if smCOG_type != None:\n",
    "                    if smCOG_type not in smCOG_list:\n",
    "                        smCOG_list.append(smCOG_type)\n",
    "                        smCOG_total_counts[smCOG_type] = 0\n",
    "                    if smCOG_type not in smCOGs[cluster_name]:\n",
    "                        smCOGs[cluster_name][smCOG_type] = 0\n",
    "                    smCOGs[cluster_name][smCOG_type] += 1\n",
    "                    smCOG_total_counts[smCOG_type] += 1\n",
    "            \n",
    "            #process nrps and pks monomer predictions\n",
    "            if \"sec_met\" not in feature.qualifiers:\n",
    "                continue\n",
    "            for f in feature.qualifiers[\"sec_met\"]:\n",
    "                if \"NRPS/PKS subtype\" in f:\n",
    "                    subtype = f.split(\":\")[1]\n",
    "                if \"Substrate specificity predictions\" in f:\n",
    "                    if \"PKS_AT\" in f:\n",
    "                        predictions = f.split(\":\")[4]\n",
    "                        pks_signature = predictions.split(\",\")[0].split()[0]\n",
    "                        minowa = predictions.split(\",\")[1].split()[0]\n",
    "                        consensus = predictions.split(\",\")[2].split()[0]\n",
    "                    if \"AMP-binding\" in f:\n",
    "                        predictions = f.split(\":\")[5]\n",
    "                        stachelhaus = predictions.split(\",\")[0].split()[0]\n",
    "                        nrpspredictor = predictions.split(\",\")[1].split()[0]\n",
    "                        pHMM = predictions.split(\",\")[2].split()[0]\n",
    "                        predicat = predictions.split(\",\")[3].split()[0]\n",
    "                        sandpuma = predictions.split(\",\")[4].split()[0]\n",
    "        if subtype != \"\":\n",
    "            if subtype not in pks_nrp_subtypes[cluster_name]:\n",
    "                pks_nrp_subtypes[cluster_name][subtype] = 0\n",
    "            pks_nrp_subtypes[cluster_name][subtype] += 1\n",
    "        if pks_signature != \"\" and \"no_call\" not in pks_signature and \"N/A\" not in pks_signature and \"n/a\" not in pks_signature:\n",
    "            if pks_signature not in pk_monomers_signature[cluster_name]:\n",
    "                pk_monomers_signature[cluster_name][pks_signature] = 0\n",
    "            pk_monomers_signature[cluster_name][pks_signature] += 1\n",
    "        if minowa != \"\" and \"no_call\" not in minowa and \"N/A\" not in minowa and \"n/a\" not in minowa:\n",
    "            if minowa not in pk_monomers_minowa[cluster_name]:\n",
    "                pk_monomers_minowa[cluster_name][minowa] = 0\n",
    "            pk_monomers_minowa[cluster_name][minowa] += 1\n",
    "        if consensus != \"\" and \"no_call\" not in consensus and \"N/A\" not in consensus and \"n/a\" not in consensus:\n",
    "            if consensus not in pk_monomers_consensus[cluster_name]:\n",
    "                pk_monomers_consensus[cluster_name][consensus] = 0\n",
    "            pk_monomers_consensus[cluster_name][consensus] += 1\n",
    "        if stachelhaus != \"\" and \"no_call\" not in stachelhaus and \"N/A\" not in stachelhaus and \"n/a\" not in stachelhaus:\n",
    "            if stachelhaus not in nrp_monomers_stachelhaus[cluster_name]:\n",
    "                nrp_monomers_stachelhaus[cluster_name][stachelhaus] = 0\n",
    "            nrp_monomers_stachelhaus[cluster_name][stachelhaus] += 1\n",
    "        if nrpspredictor != \"\" and \"no_call\" not in nrpspredictor and \"N/A\" not in nrpspredictor and \"n/a\" not in nrpspredictor:\n",
    "            if nrpspredictor not in nrp_monomers_nrps_predictor[cluster_name]:\n",
    "                nrp_monomers_nrps_predictor[cluster_name][nrpspredictor] = 0\n",
    "            nrp_monomers_nrps_predictor[cluster_name][nrpspredictor] += 1\n",
    "        if pHMM != \"\" and \"no_call\" not in pHMM and \"N/A\" not in pHMM and \"n/a\" not in pHMM:\n",
    "            if pHMM not in nrp_monomers_pHMM[cluster_name]:\n",
    "                nrp_monomers_pHMM[cluster_name][pHMM] = 0\n",
    "            nrp_monomers_pHMM[cluster_name][pHMM] += 1\n",
    "        if predicat != \"\" and \"no_call\" not in predicat and \"N/A\" not in predicat and \"n/a\" not in predicat:\n",
    "            if predicat not in nrp_monomers_predicat[cluster_name]:\n",
    "                nrp_monomers_predicat[cluster_name][predicat] = 0\n",
    "            nrp_monomers_predicat[cluster_name][predicat] += 1\n",
    "        if sandpuma != \"\" and \"no_call\" not in sandpuma and \"N/A\" not in sandpuma and \"n/a\" not in sandpuma:\n",
    "            if sandpuma not in nrp_monomers_sandpuma[cluster_name]:\n",
    "                nrp_monomers_sandpuma[cluster_name][sandpuma] = 0\n",
    "            nrp_monomers_sandpuma[cluster_name][sandpuma] += 1\n",
    "            \n",
    "        \n",
    "        #process pfam domain annotations\n",
    "        elif feature.type == \"PFAM_domain\":\n",
    "            (domain_description, pfam_id) = processPFAM(feature)\n",
    "            if pfam_id == None:\n",
    "                continue\n",
    "            if domain_description not in pfam_list:\n",
    "                pfam_list.append(domain_description)\n",
    "                pfam_id_list.append(pfam_id)\n",
    "                pfam_total_counts[domain_description] = 0\n",
    "            pfam_total_counts[domain_description] += 1\n",
    "            if domain_description not in pfam_counts[cluster_name]:\n",
    "                pfam_counts[cluster_name][domain_description] = 0\n",
    "            pfam_counts[cluster_name][domain_description] += 1\n",
    "                       \n",
    "#remove features with low counts\n",
    "smCOG_list = filterLowCounts(smCOG_list, smCOG_total_counts, feature_count_threshold)\n",
    "pfam_list = filterLowCounts(pfam_list, pfam_total_counts, feature_count_threshold)\n",
    "CDS_motif_list = filterLowCounts(CDS_motif_list, CDS_total_counts, feature_count_threshold)\n",
    "\n",
    "(pks_nrps_type_list, pks_nrps_type_counts) = getFeatureList(pks_nrp_subtypes)\n",
    "(pk_signature_list, pk_signature_counts) = getFeatureList(pk_monomers_signature)\n",
    "(pk_minowa_list, pk_minowa_counts) = getFeatureList(pk_monomers_minowa)\n",
    "(pk_consensus_list, pk_consensus_counts) = getFeatureList(pk_monomers_consensus)\n",
    "(nrp_stachelhaus_list, nrp_stachelhaus_counts) = getFeatureList(nrp_monomers_stachelhaus)\n",
    "(nrp_nrpspredictor_list, nrp_nrpspredictor_counts) = getFeatureList(nrp_monomers_nrps_predictor)\n",
    "(nrp_pHMM_list, nrp_pHMM_counts) = getFeatureList(nrp_monomers_pHMM)\n",
    "(nrp_predicat_list, nrp_predicat_counts) = getFeatureList(nrp_monomers_predicat)\n",
    "(nrp_sandpuma_list, nrp_sandpuma_counts) = getFeatureList(nrp_monomers_sandpuma)\n",
    "\n",
    "pks_nrps_type_list = filterLowCounts(pks_nrps_type_list, pks_nrps_type_counts, feature_count_threshold)\n",
    "pk_signature_list = filterLowCounts(pk_signature_list, pk_signature_counts, feature_count_threshold)\n",
    "pk_minowa_list = filterLowCounts(pk_minowa_list, pk_minowa_counts, feature_count_threshold)\n",
    "pk_consensus_list = filterLowCounts(pk_consensus_list, pk_consensus_counts, feature_count_threshold)\n",
    "nrp_stachelhaus_list = filterLowCounts(nrp_stachelhaus_list, nrp_stachelhaus_counts, feature_count_threshold)\n",
    "nrp_nrpspredictor_list = filterLowCounts(nrp_nrpspredictor_list, nrp_nrpspredictor_counts, feature_count_threshold)\n",
    "nrp_pHMM_list = filterLowCounts(nrp_pHMM_list, nrp_pHMM_counts, feature_count_threshold)\n",
    "nrp_predicat_list = filterLowCounts(nrp_predicat_list, nrp_predicat_counts, feature_count_threshold)\n",
    "nrp_sandpuma_list = filterLowCounts(nrp_sandpuma_list, nrp_sandpuma_counts, feature_count_threshold)\n",
    "\n",
    "\n",
    "#write data to files\n",
    "cluster_list_out = open(output_dir + \"cluster_list_antiSMASH.txt\", 'w')\n",
    "for cluster in CDS_motifs:\n",
    "    cluster_list_out.write(cluster + \"\\n\")   \n",
    "cluster_list_out.close()\n",
    "\n",
    "writeFeatureMatrixFile(pfam_counts, pfam_list, output_dir,\"PFAM\")\n",
    "writeFeatureMatrixFile(CDS_motifs, CDS_motif_list, output_dir,\"CDS_motifs\")\n",
    "writeFeatureMatrixFile(smCOGs, smCOG_list, output_dir, \"SMCOG\")\n",
    "writeFeatureMatrixFile(pks_nrp_subtypes, pks_nrps_type_list, output_dir, \"pks_nrps_type\")\n",
    "writeFeatureMatrixFile(pk_monomers_signature, pk_signature_list, output_dir, \"pk_signature\")\n",
    "writeFeatureMatrixFile(pk_monomers_minowa, pk_minowa_list, output_dir, \"pk_minowa\")\n",
    "writeFeatureMatrixFile(pk_monomers_consensus, pk_consensus_list, output_dir, \"pk_consensus\")\n",
    "writeFeatureMatrixFile(nrp_monomers_stachelhaus, nrp_stachelhaus_list, output_dir, \"nrp_stachelhaus\")\n",
    "writeFeatureMatrixFile(nrp_monomers_nrps_predictor, nrp_nrpspredictor_list, output_dir, \"nrp_nrpspredictor\")\n",
    "writeFeatureMatrixFile(nrp_monomers_pHMM, nrp_pHMM_list, output_dir, \"nrp_pHMM\")\n",
    "writeFeatureMatrixFile(nrp_monomers_predicat, nrp_predicat_list, output_dir, \"nrp_predicat\")\n",
    "writeFeatureMatrixFile(nrp_monomers_sandpuma, nrp_sandpuma_list, output_dir, \"nrp_sandpuma\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Process RGI files\n",
    "processes resistance gene indentifier output files and writes list of resistance gene features and feature matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "#write a matrix with counts of features to a file and a list of the features to a separate file\n",
    "def writeFeatureMatrixFile(feature_dictionary, feature_list, output_dir, feature_name):\n",
    "    matrix_outfile = open(output_dir + feature_name + \".csv\", 'w')\n",
    "    list_outfile = open(output_dir + feature_name + \"_list.txt\",'w')\n",
    "    for cluster in feature_dictionary:\n",
    "        for feature in feature_list:\n",
    "            if feature in feature_dictionary[cluster]:\n",
    "                matrix_outfile.write(str(feature_dictionary[cluster][feature]) + \",\")\n",
    "            else:\n",
    "                matrix_outfile.write(\"0,\")\n",
    "        matrix_outfile.write(\"\\n\")\n",
    "    matrix_outfile.close()\n",
    "    \n",
    "    for f in feature_list:\n",
    "        list_outfile.write(f + \"\\n\")\n",
    "    list_outfile.close()\n",
    "\n",
    "#parameters\n",
    "e_value_threshold = 0.1 #e value must be less than this threshold for resistance marker to be considered a feature\n",
    "threshold = 5 #number of times feature must occur in dataset to be included\n",
    "\n",
    "input_dir = \"RGI_output/\"\n",
    "output_dir = \"feature_matrices/\"\n",
    "resistance_genes = {}\n",
    "resistance_genes_list = []\n",
    "total_counts = {}\n",
    "\n",
    "for f in sorted(os.listdir(input_dir),key=str.lower):\n",
    "    if \".txt\" not in f:\n",
    "        continue\n",
    "    in_file = open(input_dir + f, 'r')\n",
    "    cluster_name = f[0:f.index(\".\")]\n",
    "    resistance_genes[cluster_name] = {}\n",
    "    for line in in_file:\n",
    "        if \"ORF_ID\" in line:\n",
    "            continue\n",
    "        entries = line.split(\"\\t\")\n",
    "        e_value = float(entries[7])\n",
    "        if e_value > e_value_threshold:\n",
    "            continue\n",
    "        best_hit = entries[8]\n",
    "        hit_names = entries[11]\n",
    "        if best_hit not in resistance_genes_list:\n",
    "            resistance_genes_list.append(best_hit)\n",
    "            total_counts[best_hit] = 0\n",
    "        total_counts[best_hit] += 1\n",
    "        if best_hit not in resistance_genes[cluster_name]:\n",
    "            resistance_genes[cluster_name][best_hit] = 0\n",
    "        resistance_genes[cluster_name][best_hit] += 1\n",
    "    in_file.close()\n",
    "    \n",
    "new_resistance_genes_list = []\n",
    "for gene in resistance_genes_list:\n",
    "    if total_counts[gene] >= threshold:\n",
    "        new_resistance_genes_list.append(gene)\n",
    "resistance_genes_list = new_resistance_genes_list\n",
    "\n",
    "writeFeatureMatrixFile(resistance_genes, resistance_genes_list, output_dir, \"CARD_gene\")\n",
    "cluster_list = open(\"feature_matrices/cluster_list_CARD.txt\",'w')\n",
    "for cluster in resistance_genes:\n",
    "    cluster_list.write(cluster + \"\\n\")\n",
    "cluster_list.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read SSN Results\n",
    "read results of sequenes similarity network membership and write sub-pfam features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import readFeatureFiles\n",
    "\n",
    "def readSSNFile(name):\n",
    "    infile = open(\"SSN/network_membership/\" +name+\".txt\")\n",
    "    cluster_counts = {}\n",
    "    cluster_list = []\n",
    "    for line in infile:\n",
    "        np_cluster_name = line.split(\",\")[0]\n",
    "        if np_cluster_name not in cluster_counts:\n",
    "            cluster_counts[np_cluster_name] = {}\n",
    "        gene_cluster = line.split(\",\")[1]\n",
    "        if gene_cluster not in cluster_counts[np_cluster_name]:\n",
    "            cluster_counts[np_cluster_name][gene_cluster] = 0\n",
    "        if gene_cluster not in cluster_list:\n",
    "            cluster_list.append(gene_cluster)\n",
    "        cluster_counts[np_cluster_name][gene_cluster] += 1\n",
    "    return (cluster_counts, cluster_list)\n",
    "\n",
    "#parameters\n",
    "total_threshold = 5 #feature must appear more than this many times in total to be included\n",
    "BGC_threshold = 3 #feature must appear in at least this many BGCs to be included\n",
    "\n",
    "full_cluster_list = readFeatureFiles.readClusterList(\"feature_matrices/cluster_list_CARD.txt\")\n",
    "#list of SSN files to use\n",
    "SSN_output_files = [\"thiolase,_n-terminal_domain_pfam_SSN_cluster\",\"abc_transporter_SSN_cluster\",\"acyl_transferase_pfam_SSN_cluster\",\"aaa_pfam_SSN_cluster\",\n",
    "                    \"abc2_pfam_SSN_cluster\",\"acyl-coa_dehydrogenase_c_SSN_cluster\",\"acyl-coa_dehydrogenase_n_SSN_cluster\",\n",
    "                    \"alcohol_dehydrogenase_groes_SSN_cluster\",\"alpha_beta_hydrolase_family_SSN_cluster\",\"aminotransferase_SSN_cluster\",\n",
    "                    \"beta-ketoacyl_synthase_c_SSN_cluster\",\"beta-ketoacyl_synthase_n_SSN_cluster\",\"cytochrome_p450_SSN_cluster\",\"degt_dnrj_eryc1_strs_aminotransferase_SSN_cluster\",\n",
    "                    \"enoyl_acyl_carrier_SSN_cluster\",\"erythronolide_synthase_SSN_cluster\",\"fad_binding_SSN_cluster\",\"glycosyl_transferase_family_2_SSN_cluster\",\n",
    "                    \"glycosyl_transferase_family_28_SSN_cluster\",\"glycosyl_transferase_family_group_1_SSN_cluster\",\"glycosyl_transferase_like_family_2_SSN_cluster\",\"glyoxalase_bleomycin_resistance_SSN_cluster\",\n",
    "                    \"kr_domain_SSN_cluster\",\"lanthionine_synthetase_SSN_cluster\",\n",
    "                    \"major_facilitator_SSN_cluster\",\"methyltransferase_small_SSN_cluster\",\"methyltransferase_SSN_cluster\",\n",
    "                    \"nad_dependent_epimerase_SSN_cluster\",\"ndp_hexose_SSN_cluster\",\n",
    "                    \"o_methyltransferase_SSN_cluster\",\"oxidoreductase_family_c_SSN_cluster\",\"oxidoreductase_family_SSN_cluster\",\n",
    "                    \"phosphopantetheine_SSN_cluster\",\"polyketide_cyclase_SSN_cluster\",\"polyketide_synthase_dehydratase_SSN_cluster\",\n",
    "                    \"protein_of_unknown_function_SSN_cluster\",\"short_chain_dehydrogenase_SSN_cluster\",\n",
    "                    \"snoal_like_SSN_cluster\",\"spab_c_SSN_cluster\",\"sugar_and_other_transporter_SSN_cluster\",\"transcriptional_regulator_SSN_cluster\",\"thioesterase_SSN_cluster\",\n",
    "                    \"ubie_coq5_methyltransferase_SSN_cluster\",\"udp_glucoronosyl_SSN_cluster\",\"ycao_like_SSN_cluster\",\n",
    "                    \"zinc_binding_SSN_cluster\",\"pyridine_nucleotide_oxidoreductase_SSN_cluster\"]\n",
    "\n",
    "all_cluster_counts = {}\n",
    "all_gene_cluster_list = []\n",
    "for SSN in SSN_output_files:\n",
    "    (cluster_counts, cluster_list) = readSSNFile(SSN)\n",
    "    for i in cluster_list:\n",
    "        all_gene_cluster_list.append(SSN[0:SSN.find(\"_SSN\")] + \"_\" + i)\n",
    "    for c in cluster_counts:\n",
    "        if c not in all_cluster_counts:\n",
    "            all_cluster_counts[c] = {}\n",
    "        for gc in cluster_counts[c]:\n",
    "            all_cluster_counts[c][SSN[0:SSN.find(\"_SSN\")] + \"_\" + gc] = cluster_counts[c][gc]\n",
    "            \n",
    "SSN_matrix_out = open(\"feature_matrices/SSN.csv\",'w')\n",
    "new_all_gene_cluster_list = []\n",
    "for g in all_gene_cluster_list:\n",
    "    toatal_count = 0\n",
    "    BGC_count = 0\n",
    "    for c in full_cluster_list:\n",
    "        if c not in all_cluster_counts:\n",
    "            continue\n",
    "        if g not in all_cluster_counts[c]:\n",
    "            continue\n",
    "        BGC_count += 1\n",
    "        toatal_count += all_cluster_counts[c][g]\n",
    "    if toatal_count >= total_threshold and BGC_count >= BGC_threshold:\n",
    "        new_all_gene_cluster_list.append(g)\n",
    "all_gene_cluster_list = new_all_gene_cluster_list\n",
    "\n",
    "for c in full_cluster_list:\n",
    "    if c not in all_cluster_counts:\n",
    "        for gc in all_gene_cluster_list:\n",
    "            SSN_matrix_out.write(\"0,\")\n",
    "    else:\n",
    "        for gc in all_gene_cluster_list:\n",
    "            if gc not in all_cluster_counts[c]:\n",
    "                SSN_matrix_out.write(\"0,\")\n",
    "            else:\n",
    "                SSN_matrix_out.write(str(all_cluster_counts[c][gc]) +\",\")\n",
    "    SSN_matrix_out.write(\"\\n\")\n",
    "SSN_matrix_out.close()    \n",
    "\n",
    "SSN_list_out = open(\"feature_matrices/SSN_list.txt\",'w')\n",
    "for SSN in all_gene_cluster_list:\n",
    "    SSN_list_out.write(SSN)\n",
    "SSN_list_out.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read BGC Classifications\n",
    "read classifications of natural product activity from a csv file and writes binary classifications to files. Clusters that are not listed in the spreadsheet are assumed to have unknown activity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#read spreadsheet with classifications\n",
    "cluster_info = open(\"cluster_list.csv\",'r',encoding='cp1252') #a spreadsheet with all clusters to be used and their classifications\n",
    "is_antibacterial = {}\n",
    "is_antifungal = {}\n",
    "is_cytotoxic = {}\n",
    "is_unknown = {}\n",
    "targets_gram_pos = {}\n",
    "targets_gram_neg = {}\n",
    "for line in cluster_info:\n",
    "    entries = line.split(\",\")\n",
    "    cluster_name = entries[0]\n",
    "    if entries[1] == \"yes\":\n",
    "        is_antibacterial[cluster_name] = 1\n",
    "    else:\n",
    "        is_antibacterial[cluster_name] = 0\n",
    "        \n",
    "    if entries[2] == \"yes\":\n",
    "        is_antifungal[cluster_name] = 1\n",
    "    else:\n",
    "        is_antifungal[cluster_name] = 0\n",
    "    \n",
    "    if \"cytotoxic\" in entries[3] or \"antitumor\" in entries[3] or \"anti-tumor\" in entries[3] or \"proliferative\" in entries[3]:\n",
    "        is_cytotoxic[cluster_name] = 1\n",
    "    else:\n",
    "        is_cytotoxic[cluster_name] = 0\n",
    "        \n",
    "    if \"unknown\" in entries[3]:\n",
    "        is_unknown[cluster_name] =1\n",
    "    else:\n",
    "        is_unknown[cluster_name]=0\n",
    "        \n",
    "    if \"gram pos\" in entries[7]:\n",
    "        targets_gram_pos[cluster_name] = 1\n",
    "    else:\n",
    "        targets_gram_pos[cluster_name] = 0\n",
    "    if \"gram neg\" in entries[7]:\n",
    "        targets_gram_neg[cluster_name] = 1\n",
    "    else:\n",
    "        targets_gram_neg[cluster_name] = 0\n",
    "\n",
    "#write classses\n",
    "antibacterial_out = open(\"feature_matrices/is_antibacterial.csv\",'w')\n",
    "antifungal_out = open(\"feature_matrices/is_antifungal.csv\",'w')\n",
    "cytotoxic_out = open(\"feature_matrices/is_cytotoxic.csv\",'w')\n",
    "unknown_out = open(\"feature_matrices/is_unknown.csv\",'w')\n",
    "targets_gram_pos_out = open(\"feature_matrices/targets_gram_pos.csv\",'w')\n",
    "targets_gram_neg_out = open(\"feature_matrices/targets_gram_neg.csv\",'w')\n",
    "\n",
    "#read cluster list from features\n",
    "cluster_list_input = open(\"feature_matrices/cluster_list_CARD.txt\")\n",
    "cluster_list = []\n",
    "for line in cluster_list_input:\n",
    "    c = line.replace(\"\\n\", \"\")\n",
    "    cluster_list.append(c)\n",
    "cluster_list_input.close()\n",
    "\n",
    "#only write clusters that have feature data\n",
    "for c in cluster_list:\n",
    "    if c in is_antibacterial:\n",
    "        antibacterial_out.write(str(is_antibacterial[c])+\"\\n\")\n",
    "        antifungal_out.write(str(is_antifungal[c]) + \"\\n\")\n",
    "        cytotoxic_out.write(str(is_cytotoxic[c]) + \"\\n\")\n",
    "        unknown_out.write(str(is_unknown[c]) + \"\\n\")\n",
    "        targets_gram_neg_out.write(str(targets_gram_neg[c])+\"\\n\")\n",
    "        targets_gram_pos_out.write(str(targets_gram_pos[c])+\"\\n\")\n",
    "    else:\n",
    "        print(\"cluster \" + c + \" is not in class spreadsheet\")\n",
    "        antibacterial_out.write(\"0\\n\")\n",
    "        antifungal_out.write(\"0\\n\")\n",
    "        cytotoxic_out.write(\"0\\n\")\n",
    "        unknown_out.write(\"1\\n\")\n",
    "        targets_gram_neg_out.write(\"0\\n\")\n",
    "        targets_gram_pos_out.write(\"0\\n\")\n",
    "        \n",
    "antibacterial_out.close()\n",
    "antifungal_out.close()\n",
    "cytotoxic_out.close()\n",
    "unknown_out.close()\n",
    "targets_gram_neg_out.close()\n",
    "targets_gram_pos_out.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Methods for Reading Features and Splitting Data\n",
    "This cell contains methods used by the subsequent cells, run it before running the following cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "#reads in a matrix of features from a file and returns a numpy array\n",
    "def readFeatureMatrix(filename):\n",
    "    in_file = open(filename,'r')\n",
    "    feature_matrix = []\n",
    "    for line in in_file:\n",
    "        if \",\" not in line:\n",
    "            continue\n",
    "        entries = line.split(\",\")\n",
    "        feature_matrix.append([])\n",
    "        for i in range(0,len(entries)-1):\n",
    "            feature_matrix[len(feature_matrix)-1].append(int(entries[i]))\n",
    "    in_file.close()\n",
    "    return np.array(feature_matrix)\n",
    "\n",
    "#reads file with a list of feature names\n",
    "def readFeatureList(filename):\n",
    "    in_file = open(filename,'r')\n",
    "    feature_list = []\n",
    "    for line in in_file:\n",
    "        feature_list.append(line.replace(\"\\n\",\"\"))\n",
    "    return feature_list\n",
    "\n",
    "#reads file with list of classifications for gene clusters\n",
    "def readClassesMatrix(filename):\n",
    "    class_matrix = []\n",
    "    in_file = open(filename,'r')\n",
    "    for line in in_file:\n",
    "        if len(line)>0:\n",
    "            class_matrix.append(int(line))\n",
    "    in_file.close()\n",
    "    return np.array(class_matrix)  \n",
    "\n",
    "#gets indices of all natural products with known activities, based on a list classifying activities as known (0)\n",
    "#or unknown (1)\n",
    "def getNotUnknownIndices(is_unknown):\n",
    "    is_not_unknown_indices = []\n",
    "    for i in range(0, len(is_unknown)):\n",
    "        if not is_unknown[i]:\n",
    "            is_not_unknown_indices.append(i)\n",
    "    return is_not_unknown_indices\n",
    "\n",
    "def splitData(x_vars, y_vars, validation_index, num_splits):\n",
    "    split_y = np.array_split(y_vars, num_splits)\n",
    "    split_x = np.array_split(x_vars, num_splits)\n",
    "    training_x = np.array([])\n",
    "    training_y = np.array([])\n",
    "    for i in range(0, 10):\n",
    "        if i == validation_index:\n",
    "            continue\n",
    "        if training_x.shape[0] == 0:\n",
    "            training_x = split_x[i]\n",
    "            training_y = split_y[i]\n",
    "        else:\n",
    "            training_x = np.concatenate((training_x, split_x[i]), axis=0)\n",
    "            training_y = np.concatenate((training_y, split_y[i]),axis=0)\n",
    "    return (training_x, training_y, split_x[validation_index], split_y[validation_index])\n",
    "\n",
    "def makeRandomOrder(seed, y_vars):\n",
    "    np.random.seed(seed)\n",
    "    y_vars_range = np.arange(y_vars.shape[0])\n",
    "    np.random.shuffle(y_vars_range)\n",
    "    return y_vars_range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimize Classifiers\n",
    "\n",
    "Optimizes parameters for classifiers. This cell takes a while to run. Note results may vary slightly from reported results due to differences in random state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log regression maximum accuracy: 0.7907326732673268\n",
      "Optimal l1 ratio: 0.0001 optimal alpha: 0.001\n",
      "\n",
      "SVM maximum accuracy: 0.7877128712871286\n",
      "Optimal kernel: rbf optimal c: 10 optimal gamma: 0.1\n",
      "\n",
      "Extra random trees maximum accuracy: 0.8016633663366338\n",
      "Optimal depth: None optimal n estimators: 100\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import readFeatureFiles\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn import preprocessing\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "\n",
    "\n",
    "#test classifier in ten-fold cross-validation\n",
    "#returns avg accuracy\n",
    "def validateClassifier(outfile, classifier, features, y_vars, regression):\n",
    "    avg_accuracy = 0.0\n",
    "    for i in range(0, 10):\n",
    "        (training_x, training_y, val_x, val_y) = splitData(features, y_vars, i, 10)\n",
    "        #scale features if regression classifier\n",
    "        if regression:\n",
    "            min_max_scaler = preprocessing.MinMaxScaler()\n",
    "            training_x = min_max_scaler.fit_transform(training_x)\n",
    "            val_x = min_max_scaler.transform(val_x)\n",
    "        classifier.fit(training_x, training_y)\n",
    "        score = classifier.score(val_x, val_y)\n",
    "        avg_accuracy += score\n",
    "        outfile.write(str(score) + \",\")\n",
    "    avg_accuracy /= 10.0\n",
    "    return avg_accuracy\n",
    "\n",
    "#parameters\n",
    "#classification to train classifiers on \n",
    "#options: antibacterial, antieuk (defined as antifungal, antitumor, or cytotoxic), antifungal, cytotoxic_antitumor, antigramneg, antigrampos\n",
    "classification = \"antibacterial\" \n",
    "#set random seed so results are consistent\n",
    "random.seed(1)\n",
    "#include features from SSN \n",
    "include_SSN = True\n",
    "\n",
    "pfam_features = readFeatureMatrix(\"feature_matrices/PFAM.csv\")\n",
    "card_features = readFeatureMatrix(\"feature_matrices/CARD_gene.csv\")\n",
    "smCOG_features = readFeatureMatrix(\"feature_matrices/SMCOG.csv\")\n",
    "SSN_features = readFeatureMatrix(\"feature_matrices/SSN.csv\")\n",
    "CDS_features = readFeatureMatrix(\"feature_matrices/CDS_motifs.csv\")\n",
    "\n",
    "pks_nrps_type_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pks_nrps_type.csv\")\n",
    "pk_signature_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_signature.csv\")\n",
    "pk_minowa_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_minowa.csv\")\n",
    "pk_consensus_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_consensus.csv\")\n",
    "\n",
    "nrp_stachelhaus_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_stachelhaus.csv\")\n",
    "nrp_nrpspredictor_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_nrpspredictor.csv\")\n",
    "nrp_pHMM_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_pHMM.csv\")\n",
    "nrp_predicat_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_predicat.csv\")\n",
    "nrp_sandpuma_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_sandpuma.csv\")\n",
    "\n",
    "pfam_list = readFeatureFiles.readFeatureList(\"feature_matrices/PFAM_list.txt\")\n",
    "card_list = readFeatureFiles.readFeatureList(\"feature_matrices/CARD_gene_list.txt\")\n",
    "smCOG_list = readFeatureFiles.readFeatureList(\"feature_matrices/SMCOG_list.txt\")\n",
    "SSN_list = readFeatureFiles.readFeatureList(\"feature_matrices/SSN_list.txt\")\n",
    "CDS_list = readFeatureFiles.readFeatureList(\"feature_matrices/CDS_motifs_list.txt\")\n",
    "\n",
    "pks_nrps_type_list = readFeatureFiles.readFeatureList(\"feature_matrices/pks_nrps_type_list.txt\")\n",
    "pk_signature_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_signature_list.txt\")\n",
    "pk_minowa_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_minowa_list.txt\")\n",
    "pk_consensus_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_consensus_list.txt\")\n",
    "\n",
    "nrp_stachelhaus_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_stachelhaus_list.txt\")\n",
    "nrp_nrpspredictor_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_nrpspredictor_list.txt\")\n",
    "nrp_pHMM_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_pHMM_list.txt\")\n",
    "nrp_predicat_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_predicat_list.txt\")\n",
    "nrp_sandpuma_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_sandpuma_list.txt\")\n",
    "\n",
    "#read classes\n",
    "is_antibacterial = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_antibacterial.csv\")\n",
    "is_antifungal = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_antifungal.csv\")\n",
    "is_cytotoxic = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_cytotoxic.csv\")\n",
    "is_unknown = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_unknown.csv\")\n",
    "targets_gram_pos = readFeatureFiles.readClassesMatrix(\"feature_matrices/targets_gram_pos.csv\")\n",
    "targets_gram_neg = readFeatureFiles.readClassesMatrix(\"feature_matrices/targets_gram_neg.csv\")\n",
    "full_cluster_list = readFeatureFiles.readClusterList(\"feature_matrices/cluster_list_CARD.txt\")\n",
    "is_not_unknown_indices = readFeatureFiles.getNotUnknownIndices(is_unknown)\n",
    "target_unannotated = is_antibacterial*((targets_gram_pos+targets_gram_neg)<1)\n",
    "is_not_unknown_indices_gram =  readFeatureFiles.getNotUnknownIndices(is_unknown + target_unannotated)\n",
    "\n",
    "is_antibacterial = (is_antibacterial >= 1).astype(int)\n",
    "is_antieuk = ((is_antifungal + is_cytotoxic)>=1).astype(int)\n",
    "is_gram_pos = (targets_gram_pos >= 1).astype(int)\n",
    "is_gram_neg = (targets_gram_neg >= 1).astype(int)\n",
    "\n",
    "#concatenate all features into one matrix\n",
    "features = np.concatenate((pfam_features, card_features), axis=1)\n",
    "features = np.concatenate((features,  smCOG_features), axis=1)\n",
    "features = np.concatenate((features,  CDS_features), axis=1)\n",
    "if include_SSN:\n",
    "    features = np.concatenate((features,  SSN_features), axis=1)\n",
    "features = np.concatenate((features,  pks_nrps_type_features), axis=1)\n",
    "features = np.concatenate((features,  pk_signature_features), axis=1)\n",
    "features = np.concatenate((features,  pk_minowa_features), axis=1)\n",
    "features = np.concatenate((features,  pk_consensus_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_stachelhaus_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_nrpspredictor_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_pHMM_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_predicat_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_sandpuma_features), axis=1)\n",
    "\n",
    "#process features for chosen classification\n",
    "y_vars = []\n",
    "if classification == \"antibacterial\":\n",
    "    y_vars = is_antibacterial\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "if classification == \"antieuk\":\n",
    "    y_vars = is_antieuk\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "if classification == \"antifungal\":\n",
    "    y_vars = (is_antifungal >= 1).astype(int)\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "if classification == \"cytotoxic_antitumor\":\n",
    "    y_vars = (is_cytotoxic >= 1).astype(int)\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "if classification == \"antigramneg\":\n",
    "    y_vars = is_gram_neg\n",
    "    y_vars = y_vars[is_not_unknown_indices_gram]\n",
    "    features = features[is_not_unknown_indices_gram,:]\n",
    "if classification == \"antigrampos\":\n",
    "    y_vars = is_gram_pos\n",
    "    y_vars = y_vars[is_not_unknown_indices_gram]\n",
    "    features = features[is_not_unknown_indices_gram,:]\n",
    "    \n",
    "#randomize order of features\n",
    "new_order = makeRandomOrder(0, y_vars)\n",
    "y_vars = y_vars[new_order]\n",
    "features = features[new_order,:]\n",
    "\n",
    "#parameter values to test for logistic regression\n",
    "l1_ratios = [.5, .2, .05, .1, .01, .001, .0001]\n",
    "alphas = [.5, .3, .2, .1, .01,  .001,  .0001,.00001,.000001]\n",
    "log_accuracies = {}\n",
    "max_iter = 100\n",
    "loss = \"log\"\n",
    "reg= \"elasticnet\"\n",
    "\n",
    "#test parameters for logistic regression\n",
    "for l1_ratio in l1_ratios:\n",
    "    log_accuracies[l1_ratio] =  {}\n",
    "    accuracy_outfile = open(\"classifier_optimization/log_\"+classification+loss+\"_\"+reg+str(l1_ratio)+\"_alpha_vs_accuracy.txt\",'w')\n",
    "    for a in alphas:\n",
    "        classifier = SGDClassifier(loss=loss,penalty=reg,max_iter=max_iter,alpha=a,l1_ratio=l1_ratio,tol=None)\n",
    "        accuracy_outfile.write(str(a) + \",\")\n",
    "        log_accuracies[l1_ratio][a]= validateClassifier(accuracy_outfile, classifier, features, y_vars, True)\n",
    "        accuracy_outfile.write(\"\\n\")\n",
    "    accuracy_outfile.close()\n",
    "    \n",
    "    \n",
    "#parameter values to test for SVM classifier\n",
    "kernels = ['linear', 'rbf']\n",
    "c_values = [100, 10, 1, .5, .1, .01]\n",
    "gammas = [.01, .1, 1, 10] #for rbf only\n",
    "\n",
    "svm_accuracies = {}\n",
    "#test parameters\n",
    "for k in kernels:\n",
    "    if k == \"linear\":\n",
    "        svm_accuracies[k] = {}\n",
    "        accuracy_outfile = open(\"classifier_optimization/SVM_\"+classification + \"_\" +k+\"_c_vs_accuracy.txt\",'w')\n",
    "        for c in c_values:\n",
    "            classifier = SVC(kernel=k,C=c)\n",
    "            accuracy_outfile.write(str(c) + \",\")\n",
    "            svm_accuracies[k][c]=validateClassifier(accuracy_outfile, classifier, features, y_vars, True)  \n",
    "            accuracy_outfile.write(\"\\n\")\n",
    "        accuracy_outfile.close()\n",
    "    if k == \"rbf\":\n",
    "        svm_accuracies[k] = {}\n",
    "        for g in gammas:\n",
    "            accuracy_outfile = open(\"classifier_optimization/SVM_\"+classification + \"_\" +k+\"_\"+str(g)+\"_c_vs_accuracy.txt\",'w')\n",
    "            svm_accuracies[k][g] = {}\n",
    "            for c in c_values:\n",
    "                classifier = SVC(kernel=k,C=c, gamma=g)\n",
    "                accuracy_outfile.write(str(c) + \",\")\n",
    "                svm_accuracies[k][g][c] = validateClassifier(accuracy_outfile, classifier, features, y_vars,True)\n",
    "                accuracy_outfile.write(\"\\n\")\n",
    "            accuracy_outfile.close()\n",
    "            \n",
    "random.seed(1)            \n",
    "#parameters for random forest classifier\n",
    "n_estimators = [1, 5, 10, 15, 25, 50, 100]\n",
    "max_depths = [10, 20, 50, 100, 1000, None]\n",
    "bootstrap = True\n",
    "max_features = 'auto'\n",
    "criterion = 'gini'\n",
    "\n",
    "#optimize random forest classifier\n",
    "forest_accuracies = {}\n",
    "for d in max_depths:\n",
    "    forest_accuracies[d] = {}\n",
    "    accuracy_outfile = open(\"classifier_optimization/RT_\"+classification + \"_\" +str(d)+\"_estimators_vs_accuracy.txt\",'w')\n",
    "    for n in n_estimators:\n",
    "        accuracy_outfile.write(str(n)+\",\")\n",
    "        classifier = ExtraTreesClassifier(n_estimators=n, max_depth=d,bootstrap=bootstrap, max_features=max_features, criterion=criterion, random_state=0)\n",
    "        forest_accuracies[d][n] = validateClassifier(accuracy_outfile, classifier, features, y_vars, False)\n",
    "        accuracy_outfile.write(\"\\n\")\n",
    "    accuracy_outfile.close()\n",
    "    \n",
    "#visualize results\n",
    "fig, axs = plt.subplots(3, figsize=(20, 10))\n",
    "\n",
    "cmap = cm.get_cmap('jet')\n",
    "colors = []\n",
    "for i in range(0, 7):\n",
    "    colors.append(cmap(i*1.0/7.0))\n",
    "    \n",
    "i = 0\n",
    "\n",
    "for l1_ratio in l1_ratios:\n",
    "    y_values = []\n",
    "    for a in alphas:\n",
    "        y_values.append(log_accuracies[l1_ratio][a])\n",
    "    axs[0].plot(alphas, y_values,  color=colors[i], label=\"l1: \" + str(l1_ratio))\n",
    "    i += 1\n",
    "\n",
    "axs[0].legend()\n",
    "axs[0].set_ylabel('accuracy')\n",
    "axs[0].set_xlabel('alpha')\n",
    "axs[0].set_xscale('log')\n",
    "axs[0].set_title('Log Regression Elastic Net')\n",
    "\n",
    "y_values = []\n",
    "for c in c_values:\n",
    "    y_values.append(svm_accuracies['linear'][c])\n",
    "axs[1].plot(c_values, y_values, color=colors[0], label='linear')\n",
    "\n",
    "i = 1    \n",
    "for g in gammas:\n",
    "    y_values = []\n",
    "    for c in c_values:\n",
    "        y_values.append(svm_accuracies['rbf'][g][c])\n",
    "    axs[1].plot(c_values, y_values, color=colors[i], label='rbf gamma:' + str(g))\n",
    "    i += 1\n",
    "\n",
    "axs[1].legend()\n",
    "axs[1].set_ylabel('accuracy')\n",
    "axs[1].set_xlabel('C')\n",
    "axs[1].set_xscale('log')\n",
    "axs[1].set_title('SVM')\n",
    "\n",
    "i = 0\n",
    "for d in max_depths:\n",
    "    y_values = []\n",
    "    for n in n_estimators:\n",
    "        y_values.append(forest_accuracies[d][n])\n",
    "    axs[2].plot(n_estimators,y_values, color=colors[i], label='max depth :' + str(d))\n",
    "    i += 1\n",
    "\n",
    "axs[2].legend()\n",
    "axs[2].set_ylabel('accuracy')\n",
    "axs[2].set_xlabel('Num estimators')\n",
    "axs[2].set_title('Extra Random Trees')\n",
    "\n",
    "fig.tight_layout(pad=2.0)\n",
    "\n",
    "#print optimal parameters\n",
    "max_accuracy_log = 0\n",
    "optimal_alpha = 0\n",
    "optimal_l1_ratio = 0\n",
    "for l1_ratio in l1_ratios:\n",
    "    for a in alphas:\n",
    "        if log_accuracies[l1_ratio][a] > max_accuracy_log:\n",
    "            max_accuracy_log = log_accuracies[l1_ratio][a]\n",
    "            optimal_alpha = a\n",
    "            optimal_l1_ratio = l1_ratio\n",
    "            \n",
    "print(\"Log regression maximum accuracy: \" + str(max_accuracy_log))\n",
    "print(\"Optimal l1 ratio: \" + str(optimal_l1_ratio) + \" optimal alpha: \" + str(optimal_alpha))\n",
    "print(\"\")\n",
    "\n",
    "max_accuracy_svm = 0\n",
    "optimal_kernel = \"\"\n",
    "optimal_gamma = 0\n",
    "optimal_c = 0\n",
    "for c in c_values:\n",
    "    if svm_accuracies['linear'][c] > max_accuracy_svm:\n",
    "        max_accuracy_svm = svm_accuracies['linear'][c]\n",
    "        optimal_kernel = 'linear'\n",
    "        optimal_c = c\n",
    "    for g in gammas:\n",
    "        if svm_accuracies['rbf'][g][c] > max_accuracy_svm:\n",
    "            max_accuracy_svm = svm_accuracies['rbf'][g][c]\n",
    "            optimal_kernel = 'rbf'\n",
    "            optimal_c = c\n",
    "            optimal_gamma = g\n",
    "            \n",
    "print(\"SVM maximum accuracy: \" + str(max_accuracy_svm))\n",
    "if optimal_kernel == 'linear':\n",
    "    print(\"Optimal kernel: linear optimal c: \" + str(optimal_c))\n",
    "else:\n",
    "    print(\"Optimal kernel: rbf optimal c: \" + str(optimal_c) + \" optimal gamma: \" + str(optimal_gamma))\n",
    "print(\"\")\n",
    "\n",
    "max_accuracy_forest = 0\n",
    "optimal_depth = 0\n",
    "optimal_n = 0\n",
    "for d in max_depths:\n",
    "    for n in n_estimators:\n",
    "        if forest_accuracies[d][n] > max_accuracy_forest:\n",
    "            max_accuracy_forest = forest_accuracies[d][n]\n",
    "            optimal_depth = d\n",
    "            optimal_n = n\n",
    "print(\"Extra random trees maximum accuracy: \" + str(max_accuracy_forest))\n",
    "print(\"Optimal depth: \" + str(d) + \" optimal n estimators: \" + str(optimal_n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate classifiers\n",
    "\n",
    "evaluates classifiers by various accuracy metrics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import readFeatureFiles\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn import preprocessing\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "from sklearn.metrics import balanced_accuracy_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import roc_curve\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "\n",
    "def randomizeFeatures(seed, features):\n",
    "    np.random.seed(seed)\n",
    "    random_features = features\n",
    "    for i in range(0, features.shape[1]):\n",
    "        y_vars_range = np.arange(features.shape[0])\n",
    "        np.random.shuffle(y_vars_range)\n",
    "        random_features[y_vars_range,:]\n",
    "    return random_features\n",
    "\n",
    "def writeCurve(outfile, x_axis, y_axis):\n",
    "    for i in range(0, min(x_axis.shape[0], y_axis.shape[0])):\n",
    "        outfile.write(str(x_axis[i]) + \",\" + str(y_axis[i]) + \"\\n\")\n",
    "\n",
    "#parameters\n",
    "classification = \"antibacterial\" \n",
    "#set random seed so results are consistent\n",
    "random.seed(1)\n",
    "#include features from SSN \n",
    "include_SSN = True \n",
    "#parameters for classifiers\n",
    "log_params = {}\n",
    "log_params[\"antibacterial\"] = {\"l1_ratio\":.05,\"alpha\":.01}\n",
    "log_params[\"antigrampos\"] = {\"l1_ratio\":.001,\"alpha\":.001}\n",
    "log_params[\"antigramneg\"] = {\"l1_ratio\":.05,\"alpha\":.001}\n",
    "log_params[\"antieuk\"] = {\"l1_ratio\":.001,\"alpha\":.001}\n",
    "log_params[\"antifungal\"] = {\"l1_ratio\":.0001,\"alpha\":.01}\n",
    "log_params[\"cytotoxic_antitumor\"] = {\"l1_ratio\":.001,\"alpha\":.001}\n",
    "\n",
    "svm_params = {}\n",
    "svm_params[\"antibacterial\"] = {\"kernel\":'rbf',\"C\":10,\"gamma\":0.1}\n",
    "svm_params[\"antigrampos\"] = {\"kernel\":'rbf',\"C\":10,\"gamma\":.01}\n",
    "svm_params[\"antigramneg\"] = {\"kernel\":'rbf',\"C\":10,\"gamma\":0.01}\n",
    "svm_params[\"antieuk\"] = {\"kernel\":'linear',\"C\":.1}\n",
    "svm_params[\"antifungal\"] = {\"kernel\":'rbf',\"C\":10,\"gamma\":0.1}\n",
    "svm_params[\"cytotoxic_antitumor\"] = {\"kernel\":'rbf',\"C\":100,\"gamma\":0.1}\n",
    "\n",
    "forest_params = {}\n",
    "forest_params[\"antibacterial\"] = {\"depth\":100,\"n\":50}\n",
    "forest_params[\"antigrampos\"] = {\"depth\":100,\"n\":50}\n",
    "forest_params[\"antigramneg\"] = {\"depth\":100,\"n\":25}\n",
    "forest_params[\"antieuk\"] = {\"depth\":None,\"n\":25}\n",
    "forest_params[\"antifungal\"] = {\"depth\":50,\"n\":50}\n",
    "forest_params[\"cytotoxic_antitumor\"] = {\"depth\":50,\"n\":100}\n",
    "\n",
    "#read in features\n",
    "pfam_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/PFAM.csv\")\n",
    "card_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/CARD_gene.csv\")\n",
    "smCOG_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/SMCOG.csv\")\n",
    "SSN_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/SSN.csv\")\n",
    "CDS_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/CDS_motifs.csv\")\n",
    "\n",
    "\n",
    "pks_nrps_type_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pks_nrps_type.csv\")\n",
    "pk_signature_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_signature.csv\")\n",
    "pk_minowa_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_minowa.csv\")\n",
    "pk_consensus_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_consensus.csv\")\n",
    "\n",
    "nrp_stachelhaus_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_stachelhaus.csv\")\n",
    "nrp_nrpspredictor_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_nrpspredictor.csv\")\n",
    "nrp_pHMM_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_pHMM.csv\")\n",
    "nrp_predicat_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_predicat.csv\")\n",
    "nrp_sandpuma_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_sandpuma.csv\")\n",
    "\n",
    "features = np.concatenate((pfam_features, card_features), axis=1)\n",
    "features = np.concatenate((features,  smCOG_features), axis=1)\n",
    "features = np.concatenate((features,  CDS_features), axis=1)\n",
    "if include_SSN:\n",
    "    features = np.concatenate((features,  SSN_features), axis=1)\n",
    "features = np.concatenate((features,  pks_nrps_type_features), axis=1)\n",
    "features = np.concatenate((features,  pk_signature_features), axis=1)\n",
    "features = np.concatenate((features,  pk_minowa_features), axis=1)\n",
    "features = np.concatenate((features,  pk_consensus_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_stachelhaus_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_nrpspredictor_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_pHMM_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_predicat_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_sandpuma_features), axis=1)\n",
    "\n",
    "#make randomly shuffled version of features\n",
    "features_rand = randomizeFeatures(0, features)\n",
    "\n",
    "is_antibacterial = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_antibacterial.csv\")\n",
    "is_antifungal = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_antifungal.csv\")\n",
    "is_cytotoxic = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_cytotoxic.csv\")\n",
    "is_unknown = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_unknown.csv\")\n",
    "targets_gram_pos = readFeatureFiles.readClassesMatrix(\"feature_matrices/targets_gram_pos.csv\")\n",
    "targets_gram_neg = readFeatureFiles.readClassesMatrix(\"feature_matrices/targets_gram_neg.csv\")\n",
    "full_cluster_list = readFeatureFiles.readClusterList(\"feature_matrices/cluster_list_CARD.txt\")\n",
    "is_not_unknown_indices = readFeatureFiles.getNotUnknownIndices(is_unknown)\n",
    "target_unannotated = is_antibacterial*((targets_gram_pos+targets_gram_neg)<1)\n",
    "is_not_unknown_indices_gram =  readFeatureFiles.getNotUnknownIndices(is_unknown + target_unannotated)\n",
    "\n",
    "is_antibacterial = (is_antibacterial >= 1).astype(int)\n",
    "is_antieuk = ((is_antifungal + is_cytotoxic)>=1).astype(int)\n",
    "is_gram_pos = (targets_gram_pos >= 1).astype(int)\n",
    "is_gram_neg = (targets_gram_neg >= 1).astype(int)\n",
    "\n",
    "y_vars = []\n",
    "if classification == \"antibacterial\":\n",
    "    y_vars = is_antibacterial\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "    \n",
    "if classification == \"antieuk\":\n",
    "    y_vars = is_antieuk\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "\n",
    "    \n",
    "if classification == \"antifungal\":\n",
    "    y_vars = (is_antifungal >= 1).astype(int)\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "    \n",
    "if classification == \"cytotoxic_antitumor\":\n",
    "    y_vars = (is_cytotoxic >= 1).astype(int)\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "    \n",
    "if classification == \"antigramneg\":\n",
    "    y_vars = is_gram_neg\n",
    "    y_vars = y_vars[is_not_unknown_indices_gram]\n",
    "    features = features[is_not_unknown_indices_gram,:]\n",
    "    \n",
    "if classification == \"antigrampos\":\n",
    "    y_vars = is_gram_pos\n",
    "    y_vars = y_vars[is_not_unknown_indices_gram]\n",
    "    features = features[is_not_unknown_indices_gram,:]\n",
    "    \n",
    "#reorder features\n",
    "new_order = makeRandomOrder(0, y_vars)\n",
    "y_vars = y_vars[new_order]\n",
    "features = features[new_order,:]\n",
    "features_rand = features_rand[new_order, :]\n",
    "\n",
    "#initialize classifiers\n",
    "opt_log_params = log_params[classification]\n",
    "log_classifier = SGDClassifier(loss='log',penalty='elasticnet',max_iter=100,alpha=opt_log_params[\"alpha\"],l1_ratio=opt_log_params[\"l1_ratio\"],tol=None)\n",
    "\n",
    "opt_svm_params = svm_params[classification]\n",
    "if opt_svm_params['kernel'] == \"linear\":\n",
    "    svm_classifier = SVC(kernel=\"linear\",C=opt_svm_params[\"C\"], probability=True)\n",
    "else:\n",
    "    svm_classifier = SVC(kernel=\"rbf\",C=opt_svm_params[\"C\"], gamma=opt_svm_params[\"gamma\"], probability=True)\n",
    "    \n",
    "opt_forest_params = forest_params[classification]\n",
    "tree_classifier = ExtraTreesClassifier(bootstrap=True,max_features=\"auto\",n_estimators=opt_forest_params[\"n\"], max_depth=opt_forest_params[\"depth\"], random_state=0)\n",
    "\n",
    "#do analysis, write to file, and visualize\n",
    "output_fname_base = \"classifier_metrics/\" + classification + \"_\"\n",
    "\n",
    "#output files\n",
    "roc_out = open(output_fname_base + \"roc.txt\", 'w')\n",
    "pr_out = open(output_fname_base + \"precision_recall.txt\", 'w')\n",
    "accuracy_out = open(output_fname_base + \"accuracy.txt\", \"w\")\n",
    "balanced_accuracy_out = open(output_fname_base + \"balanced_accuracy.txt\", \"w\")\n",
    "\n",
    "#cross validation\n",
    "#store results in dictionary for visualization\n",
    "roc_curves = {}\n",
    "roc_curves[\"log\"] = {}\n",
    "roc_curves[\"svm\"] = {}\n",
    "roc_curves[\"tree\"] = {}\n",
    "roc_curves[\"rnd_log\"] = {}\n",
    "roc_curves[\"rnd_svm\"] = {}\n",
    "roc_curves[\"rnd_tree\"] = {}\n",
    "\n",
    "pr_curves = {}\n",
    "pr_curves[\"log\"] = {}\n",
    "pr_curves[\"svm\"] = {}\n",
    "pr_curves[\"tree\"] = {}\n",
    "pr_curves[\"rnd_log\"] = {}\n",
    "pr_curves[\"rnd_svm\"] = {}\n",
    "pr_curves[\"rnd_tree\"] = {}\n",
    "\n",
    "accuracies = {}\n",
    "accuracies[\"log\"] = []\n",
    "accuracies[\"svm\"] = []\n",
    "accuracies[\"tree\"] = []\n",
    "accuracies[\"rnd_log\"] = []\n",
    "accuracies[\"rnd_svm\"] = []\n",
    "accuracies[\"rnd_tree\"] = []\n",
    "\n",
    "b_accuracies = {}\n",
    "b_accuracies[\"log\"] = []\n",
    "b_accuracies[\"svm\"] = []\n",
    "b_accuracies[\"tree\"] = []\n",
    "b_accuracies[\"rnd_log\"] = []\n",
    "b_accuracies[\"rnd_svm\"] = []\n",
    "b_accuracies[\"rnd_tree\"] = []\n",
    "\n",
    "for i in range(0, 10):\n",
    "    (training_x, training_y, val_x, val_y) = splitData(features, y_vars, i, 10)\n",
    "    (rnd_training_x, rnd_training_y, rnd_val_x, rnd_val_y) = splitData(features_rand, y_vars, i, 10)\n",
    "    min_max_scaler = preprocessing.MinMaxScaler()\n",
    "    scaled_training_x = min_max_scaler.fit_transform(training_x)\n",
    "    scaled_val_x = min_max_scaler.transform(val_x)\n",
    "    scaled_rnd_training_x = min_max_scaler.fit_transform(rnd_training_x)\n",
    "    scaled_rnd_val_x = min_max_scaler.transform(rnd_val_x)\n",
    "    \n",
    "    #metrics for classifiers fit to real data\n",
    "    svm_classifier.fit(scaled_training_x, training_y)\n",
    "    tree_classifier.fit(training_x, training_y)\n",
    "    log_classifier.fit(scaled_training_x, training_y)\n",
    "    \n",
    "    accuracy_out.write(str(svm_classifier.score(scaled_val_x, val_y))+\",\")\n",
    "    accuracy_out.write(str(log_classifier.score(scaled_val_x, val_y))+\",\")\n",
    "    accuracy_out.write(str(tree_classifier.score(val_x, val_y))+\",\")\n",
    "    accuracies[\"log\"].append(log_classifier.score(scaled_val_x, val_y))\n",
    "    accuracies[\"svm\"].append(svm_classifier.score(scaled_val_x, val_y))\n",
    "    accuracies[\"tree\"].append(tree_classifier.score(val_x, val_y))\n",
    "    \n",
    "    balanced_accuracy_out.write(str(balanced_accuracy_score(val_y,svm_classifier.predict(scaled_val_x))) + \",\")\n",
    "    balanced_accuracy_out.write(str(balanced_accuracy_score(val_y,log_classifier.predict(scaled_val_x))) + \",\")\n",
    "    balanced_accuracy_out.write(str(balanced_accuracy_score(val_y,tree_classifier.predict(val_x))) + \",\")\n",
    "    b_accuracies[\"log\"].append(balanced_accuracy_score(val_y,log_classifier.predict(scaled_val_x)))\n",
    "    b_accuracies[\"svm\"].append(balanced_accuracy_score(val_y,svm_classifier.predict(scaled_val_x)))\n",
    "    b_accuracies[\"tree\"].append(balanced_accuracy_score(val_y,tree_classifier.predict(val_x)))\n",
    "    \n",
    "    tree_probabilities = tree_classifier.predict_proba(val_x)\n",
    "    log_probabilities = log_classifier.predict_proba(scaled_val_x)\n",
    "    svm_probabilities = svm_classifier.predict_proba(scaled_val_x)\n",
    "    \n",
    "    fpr, tpr, thresholds = roc_curve(val_y, tree_probabilities[:,1])\n",
    "    roc_curves[\"tree\"][i] = (fpr, tpr)\n",
    "    fpr, tpr, thresholds = roc_curve(val_y, svm_probabilities[:,1])\n",
    "    roc_curves[\"svm\"][i] = (fpr, tpr)\n",
    "    fpr, tpr, thresholds = roc_curve(val_y, log_probabilities[:,1])\n",
    "    roc_curves[\"log\"][i] = (fpr, tpr)\n",
    "    \n",
    "    precision, recall, thresholds = precision_recall_curve(val_y, tree_probabilities[:,1])\n",
    "    pr_curves[\"tree\"][i] = (recall, precision)\n",
    "    precision, recall, thresholds = precision_recall_curve(val_y, svm_probabilities[:,1])\n",
    "    pr_curves[\"svm\"][i] = (recall, precision)\n",
    "    precision, recall, thresholds = precision_recall_curve(val_y, log_probabilities[:,1])\n",
    "    pr_curves[\"log\"][i] = (recall, precision)\n",
    "    \n",
    "    \n",
    "    #metrics for classifiers fit to randomly scrambled data\n",
    "    svm_classifier.fit(scaled_rnd_training_x, rnd_training_y)\n",
    "    tree_classifier.fit(rnd_training_x, rnd_training_y)\n",
    "    log_classifier.fit(scaled_rnd_training_x, rnd_training_y)\n",
    "    \n",
    "    accuracy_out.write(str(svm_classifier.score(scaled_rnd_val_x, rnd_val_y))+\",\")\n",
    "    accuracy_out.write(str(log_classifier.score(scaled_rnd_val_x, rnd_val_y))+\",\")\n",
    "    accuracy_out.write(str(tree_classifier.score(rnd_val_x, rnd_val_y))+\",\")\n",
    "    accuracies[\"rnd_log\"].append(log_classifier.score(scaled_rnd_val_x, rnd_val_y))\n",
    "    accuracies[\"rnd_svm\"].append(svm_classifier.score(scaled_rnd_val_x, rnd_val_y))\n",
    "    accuracies[\"rnd_tree\"].append(tree_classifier.score(rnd_val_x, rnd_val_y))\n",
    "    \n",
    "    balanced_accuracy_out.write(str(balanced_accuracy_score(rnd_val_y,svm_classifier.predict(scaled_rnd_val_x))) + \",\")\n",
    "    balanced_accuracy_out.write(str(balanced_accuracy_score(rnd_val_y,log_classifier.predict(scaled_rnd_val_x))) + \",\")\n",
    "    balanced_accuracy_out.write(str(balanced_accuracy_score(rnd_val_y,tree_classifier.predict(rnd_val_x))) + \",\")\n",
    "    b_accuracies[\"rnd_log\"].append(balanced_accuracy_score(rnd_val_y,log_classifier.predict(scaled_rnd_val_x)))\n",
    "    b_accuracies[\"rnd_svm\"].append(balanced_accuracy_score(rnd_val_y,svm_classifier.predict(scaled_rnd_val_x)))\n",
    "    b_accuracies[\"rnd_tree\"].append(balanced_accuracy_score(rnd_val_y,tree_classifier.predict(rnd_val_x)))\n",
    "    \n",
    "    tree_probabilities = tree_classifier.predict_proba(rnd_val_x)\n",
    "    log_probabilities = log_classifier.predict_proba(scaled_rnd_val_x)\n",
    "    svm_probabilities = svm_classifier.predict_proba(scaled_rnd_val_x)\n",
    "    \n",
    "    fpr, tpr, thresholds = roc_curve(rnd_val_y, tree_probabilities[:,1])\n",
    "    roc_curves[\"rnd_tree\"][i] = (fpr, tpr)\n",
    "    fpr, tpr, thresholds = roc_curve(rnd_val_y, svm_probabilities[:,1])\n",
    "    roc_curves[\"rnd_svm\"][i] = (fpr, tpr)\n",
    "    fpr, tpr, thresholds = roc_curve(rnd_val_y, log_probabilities[:,1])\n",
    "    roc_curves[\"rnd_log\"][i] = (fpr, tpr)\n",
    "    \n",
    "    precision, recall, thresholds = precision_recall_curve(rnd_val_y, tree_probabilities[:,1])\n",
    "    pr_curves[\"rnd_tree\"][i] = (recall, precision)\n",
    "    recision, recall, thresholds = precision_recall_curve(rnd_val_y, svm_probabilities[:,1])\n",
    "    pr_curves[\"rnd_svm\"][i] = (recall, precision)\n",
    "    precision, recall, thresholds = precision_recall_curve(rnd_val_y, log_probabilities[:,1])\n",
    "    pr_curves[\"rnd_log\"][i] = (recall, precision)\n",
    "    \n",
    "    balanced_accuracy_out.write(\"\\n\")\n",
    "    accuracy_out.write(\"\\n\")\n",
    "    \n",
    "accuracy_out.close()\n",
    "balanced_accuracy_out.close()\n",
    "\n",
    "#write ROC and pr curves for one trial\n",
    "writeCurve(roc_out, roc_curves[\"svm\"][0][0],roc_curves[\"svm\"][0][1])\n",
    "writeCurve(roc_out, roc_curves[\"log\"][0][0],roc_curves[\"log\"][0][1])\n",
    "writeCurve(roc_out, roc_curves[\"tree\"][0][0],roc_curves[\"tree\"][0][1])\n",
    "writeCurve(roc_out, roc_curves[\"rnd_svm\"][0][0],roc_curves[\"rnd_svm\"][0][1])\n",
    "writeCurve(roc_out, roc_curves[\"rnd_log\"][0][0],roc_curves[\"rnd_log\"][0][1])\n",
    "writeCurve(roc_out, roc_curves[\"rnd_tree\"][0][0],roc_curves[\"rnd_tree\"][0][1])\n",
    "roc_out.close()\n",
    "\n",
    "writeCurve(pr_out, pr_curves[\"svm\"][0][0],pr_curves[\"svm\"][0][1])\n",
    "writeCurve(pr_out, pr_curves[\"log\"][0][0],pr_curves[\"log\"][0][1])\n",
    "writeCurve(pr_out, pr_curves[\"tree\"][0][0],pr_curves[\"tree\"][0][1])\n",
    "writeCurve(pr_out, pr_curves[\"rnd_svm\"][0][0],pr_curves[\"rnd_svm\"][0][1])\n",
    "writeCurve(pr_out, pr_curves[\"rnd_log\"][0][0],pr_curves[\"rnd_log\"][0][1])\n",
    "writeCurve(pr_out, pr_curves[\"rnd_tree\"][0][0],pr_curves[\"rnd_tree\"][0][1])\n",
    "pr_out.close\n",
    "\n",
    "#visualize results\n",
    "fig, axs = plt.subplots(3, figsize=(15, 12))\n",
    "cmap = cm.get_cmap('jet')\n",
    "colors = []\n",
    "for i in range(0, 6):\n",
    "    colors.append(cmap(i*1.0/6.0))\n",
    "    \n",
    "mean_log_acc = np.mean(b_accuracies[\"log\"])\n",
    "mean_svm_acc = np.mean(b_accuracies[\"svm\"])\n",
    "mean_tree_acc = np.mean(b_accuracies[\"tree\"])\n",
    "mean_rnd_log_acc =np.mean(b_accuracies[\"rnd_log\"])\n",
    "mean_rnd_svm_acc = np.mean(b_accuracies[\"rnd_svm\"])\n",
    "mean_rnd_tree_acc = np.mean(b_accuracies[\"rnd_tree\"])\n",
    "\n",
    "mean_log_sd = np.std(b_accuracies[\"log\"])\n",
    "mean_svm_sd = np.std(b_accuracies[\"svm\"])\n",
    "mean_tree_sd = np.std(b_accuracies[\"tree\"])\n",
    "mean_rnd_log_sd =np.std(b_accuracies[\"rnd_log\"])\n",
    "mean_rnd_svm_sd = np.std(b_accuracies[\"rnd_svm\"])\n",
    "mean_rnd_tree_sd = np.std(b_accuracies[\"rnd_tree\"])\n",
    "\n",
    "bar_labels = [\"log\", \"svm\", \"tree\", \"rnd log\", \"rnd svm\", \"rnd tree\"]\n",
    "x_pos = np.arange(len(bar_labels))\n",
    "means = [mean_log_acc, mean_svm_acc, mean_tree_acc, mean_rnd_log_acc, mean_rnd_svm_acc, mean_rnd_tree_acc]\n",
    "error = [mean_log_sd, mean_svm_sd, mean_tree_sd, mean_rnd_log_sd, mean_rnd_svm_sd, mean_rnd_tree_sd]\n",
    "axs[0].bar(x_pos, means, yerr=error, align='center', capsize=10, color=(colors[0], colors[2], colors[5],colors[0], colors[2], colors[5]))\n",
    "axs[0].set_xticks(x_pos)\n",
    "axs[0].set_xticklabels(bar_labels)\n",
    "axs[0].set_title(\"Balanced Accuracy of Classifiers\")\n",
    "axs[0].set_ylabel(\"Balanced Accuracy\")\n",
    "\n",
    "axs[1].plot(roc_curves[\"log\"][0][0], roc_curves[\"log\"][0][1], color=colors[0], label='log')\n",
    "axs[1].plot(roc_curves[\"svm\"][0][0], roc_curves[\"svm\"][0][1], color=colors[2], label='svm')\n",
    "axs[1].plot(roc_curves[\"tree\"][0][0], roc_curves[\"tree\"][0][1], color=colors[5], label='tree')\n",
    "for i in range(1, 10):\n",
    "    axs[1].plot(roc_curves[\"log\"][i][0], roc_curves[\"log\"][i][1], color=colors[0])\n",
    "    axs[1].plot(roc_curves[\"svm\"][i][0], roc_curves[\"svm\"][i][1], color=colors[2])\n",
    "    axs[1].plot(roc_curves[\"tree\"][i][0], roc_curves[\"tree\"][i][1], color=colors[5])\n",
    "axs[1].set_title(\"ROC\")\n",
    "axs[1].set_ylabel(\"TPR\")\n",
    "axs[1].set_xlabel(\"FPR\")\n",
    "axs[1].legend()\n",
    "\n",
    "\n",
    "axs[2].plot(pr_curves[\"log\"][0][0], pr_curves[\"log\"][0][1], color=colors[0], label='log')\n",
    "axs[2].plot(pr_curves[\"svm\"][0][0], pr_curves[\"svm\"][0][1], color=colors[2], label='svm')\n",
    "axs[2].plot(pr_curves[\"tree\"][0][0], pr_curves[\"tree\"][0][1], color=colors[5], label='tree')\n",
    "for i in range(1, 10):\n",
    "    axs[2].plot(pr_curves[\"log\"][i][0], pr_curves[\"log\"][i][1], color=colors[0])\n",
    "    axs[2].plot(pr_curves[\"svm\"][i][0], pr_curves[\"svm\"][i][1], color=colors[2])\n",
    "    axs[2].plot(pr_curves[\"tree\"][i][0], pr_curves[\"tree\"][i][1], color=colors[5])\n",
    "axs[2].set_title(\"precision-recall curve\")\n",
    "axs[2].set_ylabel(\"precision\")\n",
    "axs[2].set_xlabel(\"recall\")\n",
    "axs[2].legend()\n",
    "fig.tight_layout(pad=2.0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyze Features\n",
    "Prints top and bottom 10 features based on logistic regression coefficients, writes full list of coefficients to file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peptidase C39 family: 0.5851985983812773\n",
      "bcrA: 0.5104411076451791\n",
      "tcmA: 0.40196200191090964\n",
      "SMCOG1288:ABC_transporter_related_protein: 0.3901366866362491\n",
      "SpaB C-terminal domain: 0.3766702352726347\n",
      "Lanthionine synthetase C-like protein: 0.37442352147206626\n",
      "Lantibiotic dehydratase, N terminus: 0.3742543843496193\n",
      " PKS/NRPS-like protein: 0.37058189992834956\n",
      "sav1866: 0.35023560107681784\n",
      "Integral membrane protein DUF95: 0.3397002458384145\n",
      "\n",
      "Putative S-adenosyl-L-methionine-dependent methyltransferase: -0.41536310539232646\n",
      "thioesterase_3: -0.329050038437865\n",
      "Squalene/phytoene synthase: -0.3130249580933654\n",
      "Bacterial sugar transferase: -0.3051577691771088\n",
      "SMCOG1146:sugar_transferase: -0.3051577691771088\n",
      "O-antigen ligase like membrane protein: -0.2984116670277044\n",
      "mal: -0.2875290159243887\n",
      "ABC transporter transmembrane region 2: -0.28030395602554165\n",
      "Glycosyl transferase family 2: -0.2794741028694745\n",
      "Glycosyltransferase like family 2: -0.2753451321987481\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn import preprocessing\n",
    "import readFeatureFiles\n",
    "\n",
    "#classification to rank features for\n",
    "classification = \"antibacterial\"\n",
    "#set random seed so results are consistent\n",
    "random.seed(1)\n",
    "#include features from SSN \n",
    "include_SSN = True\n",
    "\n",
    "#parameters for classifiers\n",
    "log_params = {}\n",
    "log_params[\"antibacterial\"] = {\"l1_ratio\":.05,\"alpha\":.01}\n",
    "log_params[\"antigrampos\"] = {\"l1_ratio\":.001,\"alpha\":.001}\n",
    "log_params[\"antigramneg\"] = {\"l1_ratio\":.05,\"alpha\":.001}\n",
    "log_params[\"antieuk\"] = {\"l1_ratio\":.001,\"alpha\":.001}\n",
    "log_params[\"antifungal\"] = {\"l1_ratio\":.0001,\"alpha\":.01}\n",
    "log_params[\"cytotoxic_antitumor\"] = {\"l1_ratio\":.001,\"alpha\":.001}\n",
    "\n",
    "\n",
    "#read in features\n",
    "pfam_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/PFAM.csv\")\n",
    "card_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/CARD_gene.csv\")\n",
    "smCOG_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/SMCOG.csv\")\n",
    "SSN_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/SSN.csv\")\n",
    "CDS_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/CDS_motifs.csv\")\n",
    "\n",
    "\n",
    "pks_nrps_type_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pks_nrps_type.csv\")\n",
    "pk_signature_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_signature.csv\")\n",
    "pk_minowa_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_minowa.csv\")\n",
    "pk_consensus_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_consensus.csv\")\n",
    "\n",
    "nrp_stachelhaus_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_stachelhaus.csv\")\n",
    "nrp_nrpspredictor_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_nrpspredictor.csv\")\n",
    "nrp_pHMM_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_pHMM.csv\")\n",
    "nrp_predicat_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_predicat.csv\")\n",
    "nrp_sandpuma_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_sandpuma.csv\")\n",
    "\n",
    "#read in list of feature lables\n",
    "pfam_list = readFeatureFiles.readFeatureList(\"feature_matrices/PFAM_list.txt\")\n",
    "card_list = readFeatureFiles.readFeatureList(\"feature_matrices/CARD_gene_list.txt\")\n",
    "smCOG_list = readFeatureFiles.readFeatureList(\"feature_matrices/SMCOG_list.txt\")\n",
    "SSN_list = readFeatureFiles.readFeatureList(\"feature_matrices/SSN_list.txt\")\n",
    "CDS_list = readFeatureFiles.readFeatureList(\"feature_matrices/CDS_motifs_list.txt\")\n",
    "\n",
    "pks_nrps_type_list = readFeatureFiles.readFeatureList(\"feature_matrices/pks_nrps_type_list.txt\")\n",
    "pk_signature_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_signature_list.txt\")\n",
    "pk_minowa_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_minowa_list.txt\")\n",
    "pk_consensus_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_consensus_list.txt\")\n",
    "\n",
    "nrp_stachelhaus_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_stachelhaus_list.txt\")\n",
    "nrp_nrpspredictor_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_nrpspredictor_list.txt\")\n",
    "nrp_pHMM_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_pHMM_list.txt\")\n",
    "nrp_predicat_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_predicat_list.txt\")\n",
    "nrp_sandpuma_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_sandpuma_list.txt\")\n",
    "\n",
    "#concatenate features\n",
    "features = np.concatenate((pfam_features, card_features), axis=1)\n",
    "features = np.concatenate((features,  smCOG_features), axis=1)\n",
    "features = np.concatenate((features,  CDS_features), axis=1)\n",
    "if include_SSN:\n",
    "    features = np.concatenate((features,  SSN_features), axis=1)\n",
    "features = np.concatenate((features,  pks_nrps_type_features), axis=1)\n",
    "features = np.concatenate((features,  pk_signature_features), axis=1)\n",
    "features = np.concatenate((features,  pk_minowa_features), axis=1)\n",
    "features = np.concatenate((features,  pk_consensus_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_stachelhaus_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_nrpspredictor_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_pHMM_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_predicat_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_sandpuma_features), axis=1)\n",
    "\n",
    "feature_list = pfam_list +card_list+smCOG_list+CDS_list+SSN_list+pks_nrps_type_list+pk_signature_list+pk_minowa_list+pk_consensus_list+nrp_stachelhaus_list+nrp_nrpspredictor_list+nrp_pHMM_list+nrp_predicat_list+nrp_sandpuma_list\n",
    "\n",
    "\n",
    "is_antibacterial = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_antibacterial.csv\")\n",
    "is_antifungal = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_antifungal.csv\")\n",
    "is_cytotoxic = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_cytotoxic.csv\")\n",
    "is_unknown = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_unknown.csv\")\n",
    "targets_gram_pos = readFeatureFiles.readClassesMatrix(\"feature_matrices/targets_gram_pos.csv\")\n",
    "targets_gram_neg = readFeatureFiles.readClassesMatrix(\"feature_matrices/targets_gram_neg.csv\")\n",
    "full_cluster_list = readFeatureFiles.readClusterList(\"feature_matrices/cluster_list_CARD.txt\")\n",
    "is_not_unknown_indices = readFeatureFiles.getNotUnknownIndices(is_unknown)\n",
    "target_unannotated = is_antibacterial*((targets_gram_pos+targets_gram_neg)<1)\n",
    "is_not_unknown_indices_gram =  readFeatureFiles.getNotUnknownIndices(is_unknown + target_unannotated)\n",
    "\n",
    "is_antibacterial = (is_antibacterial >= 1).astype(int)\n",
    "is_antieuk = ((is_antifungal + is_cytotoxic)>=1).astype(int)\n",
    "is_gram_pos = (targets_gram_pos >= 1).astype(int)\n",
    "is_gram_neg = (targets_gram_neg >= 1).astype(int)\n",
    "\n",
    "y_vars = []\n",
    "if classification == \"antibacterial\":\n",
    "    y_vars = is_antibacterial\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "    \n",
    "if classification == \"antieuk\":\n",
    "    y_vars = is_antieuk\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "\n",
    "    \n",
    "if classification == \"antifungal\":\n",
    "    y_vars = (is_antifungal >= 1).astype(int)\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "    \n",
    "if classification == \"cytotoxic_antitumor\":\n",
    "    y_vars = (is_cytotoxic >= 1).astype(int)\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "    \n",
    "if classification == \"antigramneg\":\n",
    "    y_vars = is_gram_neg\n",
    "    y_vars = y_vars[is_not_unknown_indices_gram]\n",
    "    features = features[is_not_unknown_indices_gram,:]\n",
    "    \n",
    "if classification == \"antigrampos\":\n",
    "    y_vars = is_gram_pos\n",
    "    y_vars = y_vars[is_not_unknown_indices_gram]\n",
    "    features = features[is_not_unknown_indices_gram,:]\n",
    "\n",
    "#train logistic regression classifier    \n",
    "min_max_scaler = preprocessing.MinMaxScaler()\n",
    "scaled_training_x = min_max_scaler.fit_transform(features)\n",
    "opt_log_params = log_params[classification]\n",
    "log_classifier = SGDClassifier(loss='log',penalty='elasticnet',max_iter=100,alpha=opt_log_params[\"alpha\"],l1_ratio=opt_log_params[\"l1_ratio\"],tol=None)\n",
    "log_classifier.fit(scaled_training_x, y_vars)\n",
    "\n",
    "#get and sort coefficients and write results to file\n",
    "log_coeff = log_classifier.coef_[0]\n",
    "index_log_coeff = np.argsort(-1*log_coeff)\n",
    "output_log = open(\"feature_scores/\"+classification+\"_log_coeff.txt\",'w')\n",
    "for i in index_log_coeff:\n",
    "    output_log.write(feature_list[i].replace(\",\",\"_\")+\",\")\n",
    "    output_log.write(str(log_coeff[i])+\"\\n\")\n",
    "output_log.close()\n",
    "\n",
    "#print top and bottom 10 classifiers and coefficients\n",
    "for i in range(0, 10):\n",
    "    print(feature_list[index_log_coeff[i]] + \": \" + str(log_coeff[index_log_coeff[i]]))\n",
    "print(\"\")                                                                \n",
    "for i in range(0, 10):\n",
    "    print(feature_list[index_log_coeff[len(index_log_coeff)-(i+1)]] + \": \" + str(log_coeff[index_log_coeff[len(index_log_coeff)-(i+1)]]))                                                             "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Write Feature Matrices for new BGCs\n",
    "Determines features for new BGCs so that their activity can be predicted. \n",
    "\n",
    "Determining SSN features for new clusters requires blast to be installed and is slow. Set include_SSN = False in this cell and the next to not include SSN features. This has a minimal effect on accuracy. If you are using SSNs blast_exe must be set to the full path of the blastp executable.\n",
    "\n",
    "antiSMASH and RGI results must have matching files. File extension for antiSMASH results must be .gbk and the file extension for the RGI results must be .txt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import SSN_tools\n",
    "import readFeatureFiles\n",
    "from Bio import SeqIO\n",
    "\n",
    "new_BGCs_dir = \"BGCs_for_prediction/\"\n",
    "#blast is required to determine SSN membership, set include SSN to false to skip this step\n",
    "include_SSN = False\n",
    "blast_exe = \"\" \n",
    "e_value_threshold = 0.1\n",
    "score_cutoff = 20\n",
    "\n",
    "SSN_pfam_names = [\"Thiolase, N-terminal domain\",\"ABC transporter\",\"Acyl transferase domain\",\"AAA domain\",\n",
    "                 \"ABC-2 family transporter protein\",\"Acyl-CoA dehydrogenase, C-terminal domain\",\"Acyl-CoA dehydrogenase, N-terminal domain\",\n",
    "                 \"Alcohol dehydrogenase GroES-like domain\",\"Alpha/beta hydrolase family\",\"Aminotransferase class I and II\",\n",
    "                 \"Beta-ketoacyl synthase, C-terminal domain\",\"Beta-ketoacyl synthase, N-terminal domain\",\"Cytochrome P450\",\"DegT/DnrJ/EryC1/StrS aminotransferase family\",\n",
    "                 \"Enoyl-(Acyl carrier protein) reductase\",\"Erythronolide synthase docking\",\"FAD binding domain\",\"Glycosyl transferase family 2\",\n",
    "                 \"Glycosyltransferase family 28 N-terminal domain\",\"Glycosyl transferases group 1\",\"Glycosyltransferase like family 2\",\"Glyoxalase/Bleomycin resistance protein/Dioxygenase superfamily\",\n",
    "                 \"KR domain\",\"Lanthionine synthetase C-like protein\",\n",
    "                 \"Major Facilitator Superfamily\",\"Methyltransferase small domain\",\"Methyltransferase domain\",\n",
    "                 \"NAD dependent epimerase/dehydratase family\",\"NDP-hexose 2,3-dehydratase\",\n",
    "                 \"O-methyltransferase\",\"Oxidoreductase family, C-terminal alpha/beta domain\",\"Oxidoreductase family, NAD-binding Rossmann fold\",\n",
    "                 \"Phosphopantetheine attachment site\",\"Polyketide cyclase / dehydrase and lipid transport\",\"Polyketide synthase dehydratase\",\n",
    "                 \"Protein of unknown function (DUF1205)\",\n",
    "                 \"short chain dehydrogenase\",\"SnoaL-like domain\",\"SpaB C-terminal domain\",\n",
    "                 \"Sugar (and other) transporter\",\"transcriptional_regulatory_protein,_c_terminal_domains\",\"Thioesterase superfamily\",\"ubiE/COQ5 methyltransferase family\",\"UDP-glucoronosyl and UDP-glucosyl transferase\",\"YcaO-like family\",\n",
    "                 \"Zinc-binding dehydrogenase\",\"pyridine_nucleotide-disulphide_oxidoreductase\"]\n",
    "\n",
    "\n",
    "#read in list of features to use\n",
    "used_pfam_list = readFeatureFiles.readFeatureList(\"feature_matrices/PFAM_list.txt\")\n",
    "used_CDS_list = readFeatureFiles.readFeatureList(\"feature_matrices/CDS_motifs_list.txt\")\n",
    "used_smCOG_list = readFeatureFiles.readFeatureList(\"feature_matrices/SMCOG_list.txt\")\n",
    "used_pks_nrps_type_list = readFeatureFiles.readFeatureList(\"feature_matrices/pks_nrps_type_list.txt\")\n",
    "used_pk_signature_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_signature_list.txt\")\n",
    "used_pk_minowa_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_minowa_list.txt\")\n",
    "used_pk_consensus_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_consensus_list.txt\")\n",
    "    \n",
    "used_nrp_stachelhaus_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_stachelhaus_list.txt\")\n",
    "used_nrp_nrps_predictor_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_nrpspredictor_list.txt\")\n",
    "used_nrp_pHMM_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_pHMM_list.txt\")\n",
    "used_nrp_predicat_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_predicat_list.txt\")\n",
    "used_nrp_sandpuma_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_sandpuma_list.txt\")\n",
    "    \n",
    "used_resistance_genes_list = readFeatureFiles.readFeatureList(\"feature_matrices/CARD_gene_list.txt\")\n",
    "SSN_list = readFeatureFiles.readFeatureList(\"feature_matrices/SSN_list.txt\")\n",
    "\n",
    "#read files\n",
    "CDS_motifs = {}\n",
    "smCOGs = {}\n",
    "pfam_counts = {}\n",
    "pks_nrp_subtypes = {}\n",
    "\n",
    "pk_monomers_signature = {}\n",
    "pk_monomers_minowa = {}\n",
    "pk_monomers_consensus = {}\n",
    "\n",
    "\n",
    "nrp_monomers_stachelhaus = {}\n",
    "nrp_monomers_nrps_predictor = {}\n",
    "nrp_monomers_pHMM = {}\n",
    "nrp_monomers_predicat = {}\n",
    "nrp_monomers_sandpuma = {}\n",
    "\n",
    "resistance_genes = {}\n",
    "\n",
    "cluster_list = []\n",
    "CARD_cluster_list = []\n",
    "for f in sorted(os.listdir(new_BGCs_dir + \"antiSMASH\")):\n",
    "    if \".gb\" not in f and \".gbk\" not in f:\n",
    "        continue\n",
    "    \n",
    "    record = SeqIO.read(open(new_BGCs_dir + \"antiSMASH/\" + f, 'r'),\"genbank\")\n",
    "    features = record.features\n",
    "    cluster_name = f[0:f.rfind(\".\")]\n",
    "    cluster_list.append(cluster_name)\n",
    "    \n",
    "    CDS_motifs[cluster_name] = {}\n",
    "    smCOGs[cluster_name] = {}\n",
    "    pfam_counts[cluster_name] = {}\n",
    "    pks_nrp_subtypes[cluster_name] = {}\n",
    "    pk_monomers_signature[cluster_name] = {}\n",
    "    pk_monomers_minowa[cluster_name] = {}\n",
    "    pk_monomers_consensus[cluster_name] = {}\n",
    "    nrp_monomers_stachelhaus[cluster_name] = {}\n",
    "    nrp_monomers_nrps_predictor[cluster_name] = {}\n",
    "    nrp_monomers_pHMM[cluster_name] = {}\n",
    "    nrp_monomers_predicat[cluster_name] = {}\n",
    "    nrp_monomers_sandpuma[cluster_name] = {}\n",
    "    subtype = \"\"\n",
    "    pks_signature = \"\"\n",
    "    minowa = \"\"\n",
    "    consensus = \"\"\n",
    "    stachelhaus = \"\"\n",
    "    nrpspredictor = \"\"\n",
    "    pHMM = \"\"\n",
    "    predicat = \"\"\n",
    "    sandpuma = \"\"\n",
    "    for feature in features:\n",
    "        subtype = \"\"\n",
    "        pks_signature = \"\"\n",
    "        minowa = \"\"\n",
    "        consensus = \"\"\n",
    "        stachelhaus = \"\"\n",
    "        nrpspredictor = \"\"\n",
    "        pHMM = \"\"\n",
    "        predicat = \"\"\n",
    "        sandpuma = \"\"\n",
    "        if feature.type == \"CDS\":\n",
    "            if \"sec_met\" not in feature.qualifiers:\n",
    "                continue\n",
    "            for f in feature.qualifiers[\"sec_met\"]:\n",
    "                if \"NRPS/PKS subtype\" in f:\n",
    "                    subtype = f.split(\":\")[1]\n",
    "                    \n",
    "                if \"Substrate specificity predictions\" in f:\n",
    "                    #print f\n",
    "                    if \"PKS_AT\" in f:\n",
    "                        predictions = f.split(\":\")[4]\n",
    "                        #print predictions\n",
    "                        pks_signature = predictions.split(\",\")[0].split()[0]\n",
    "                        minowa = predictions.split(\",\")[1].split()[0]\n",
    "                        consensus = predictions.split(\",\")[2].split()[0]\n",
    "                    if \"AMP-binding\" in f:\n",
    "                        predictions = f.split(\":\")[5]\n",
    "                        stachelhaus = predictions.split(\",\")[0].split()[0]\n",
    "                        nrpspredictor = predictions.split(\",\")[1].split()[0]\n",
    "                        pHMM = predictions.split(\",\")[2].split()[0]\n",
    "                        predicat = predictions.split(\",\")[3].split()[0]\n",
    "                        sandpuma = predictions.split(\",\")[4].split()[0]\n",
    "        if subtype != \"\":\n",
    "            if subtype not in pks_nrp_subtypes[cluster_name]:\n",
    "                pks_nrp_subtypes[cluster_name][subtype] = 0\n",
    "            pks_nrp_subtypes[cluster_name][subtype] += 1\n",
    "        if pks_signature != \"\" and \"no_call\" not in pks_signature and \"N/A\" not in pks_signature and \"n/a\" not in pks_signature:\n",
    "            if pks_signature not in pk_monomers_signature[cluster_name]:\n",
    "                pk_monomers_signature[cluster_name][pks_signature] = 0\n",
    "            pk_monomers_signature[cluster_name][pks_signature] += 1\n",
    "        if minowa != \"\" and \"no_call\" not in minowa and \"N/A\" not in minowa and \"n/a\" not in minowa:\n",
    "            if minowa not in pk_monomers_minowa[cluster_name]:\n",
    "                pk_monomers_minowa[cluster_name][minowa] = 0\n",
    "            pk_monomers_minowa[cluster_name][minowa] += 1\n",
    "        if consensus != \"\" and \"no_call\" not in consensus and \"N/A\" not in consensus and \"n/a\" not in consensus:\n",
    "            if consensus not in pk_monomers_consensus[cluster_name]:\n",
    "                pk_monomers_consensus[cluster_name][consensus] = 0\n",
    "            pk_monomers_consensus[cluster_name][consensus] += 1\n",
    "        if stachelhaus != \"\" and \"no_call\" not in stachelhaus and \"N/A\" not in stachelhaus and \"n/a\" not in stachelhaus:\n",
    "            if stachelhaus not in nrp_monomers_stachelhaus[cluster_name]:\n",
    "                nrp_monomers_stachelhaus[cluster_name][stachelhaus] = 0\n",
    "            nrp_monomers_stachelhaus[cluster_name][stachelhaus] += 1\n",
    "        if nrpspredictor != \"\" and \"no_call\" not in nrpspredictor and \"N/A\" not in nrpspredictor and \"n/a\" not in nrpspredictor:\n",
    "            if nrpspredictor not in nrp_monomers_nrps_predictor[cluster_name]:\n",
    "                nrp_monomers_nrps_predictor[cluster_name][nrpspredictor] = 0\n",
    "            nrp_monomers_nrps_predictor[cluster_name][nrpspredictor] += 1\n",
    "        if pHMM != \"\" and \"no_call\" not in pHMM and \"N/A\" not in pHMM and \"n/a\" not in pHMM:\n",
    "            if pHMM not in nrp_monomers_pHMM[cluster_name]:\n",
    "                nrp_monomers_pHMM[cluster_name][pHMM] = 0\n",
    "            nrp_monomers_pHMM[cluster_name][pHMM] += 1\n",
    "        if predicat != \"\" and \"no_call\" not in predicat and \"N/A\" not in predicat and \"n/a\" not in predicat:\n",
    "            if predicat not in nrp_monomers_predicat[cluster_name]:\n",
    "                nrp_monomers_predicat[cluster_name][predicat] = 0\n",
    "            nrp_monomers_predicat[cluster_name][predicat] += 1\n",
    "        if sandpuma != \"\" and \"no_call\" not in sandpuma and \"N/A\" not in sandpuma and \"n/a\" not in sandpuma:\n",
    "            if sandpuma not in nrp_monomers_sandpuma[cluster_name]:\n",
    "                nrp_monomers_sandpuma[cluster_name][sandpuma] = 0\n",
    "            nrp_monomers_sandpuma[cluster_name][sandpuma] += 1\n",
    "            \n",
    "            \n",
    "        if feature.type == \"CDS_motif\":\n",
    "            note_text = feature.qualifiers['note'][0]\n",
    "            if \"(\" not in note_text:\n",
    "                continue\n",
    "            motif_name = note_text[0:note_text.index(\"(\")-1]\n",
    "            if motif_name not in CDS_motifs[cluster_name]:\n",
    "                CDS_motifs[cluster_name][motif_name] = 0\n",
    "            CDS_motifs[cluster_name][motif_name] += 1\n",
    "        elif feature.type == \"CDS\":\n",
    "            if \"note\" in feature.qualifiers:\n",
    "                for note in feature.qualifiers[\"note\"]:\n",
    "                    if \"smCOG\" in note:\n",
    "                        if \":\" not in note or \"(\" not in note:\n",
    "                            continue\n",
    "                        smCOG_type = note[note.index(\":\")+2:note.index(\"(\")-1]\n",
    "                        if smCOG_type not in smCOG_list:\n",
    "                            smCOG_list.append(smCOG_type)\n",
    "                            smCOG_total_counts[smCOG_type] = 0\n",
    "                        if smCOG_type not in smCOGs[cluster_name]:\n",
    "                            smCOGs[cluster_name][smCOG_type] = 0\n",
    "                        smCOGs[cluster_name][smCOG_type] += 1\n",
    "                        smCOG_total_counts[smCOG_type] += 1\n",
    "        elif feature.type == \"PFAM_domain\":\n",
    "            score = float(feature.qualifiers[\"score\"][0])\n",
    "            if score <score_cutoff:\n",
    "                continue\n",
    "            domain_description = feature.qualifiers[\"description\"][0]\n",
    "            pfam_id = feature.qualifiers[\"db_xref\"][0]\n",
    "            pfam_id = pfam_id[pfam_id.find(\" \")+1:len(pfam_id)]\n",
    "\n",
    "            if domain_description not in pfam_counts[cluster_name]:\n",
    "                pfam_counts[cluster_name][domain_description] = 0\n",
    "            pfam_counts[cluster_name][domain_description] += 1\n",
    "            \n",
    "for f in sorted(os.listdir(new_BGCs_dir + \"CARD\")):\n",
    "    if \".txt\" not in f:\n",
    "        continue\n",
    "    cluster_name = f[0:f.rfind(\".\")]\n",
    "    CARD_cluster_list.append(cluster_name)\n",
    "    resistance_genes[cluster_name] = {}\n",
    "    in_file = open(new_BGCs_dir + \"CARD/\" +f, 'r')\n",
    "    for line in in_file:\n",
    "        if \"ORF_ID\" in line:\n",
    "            continue\n",
    "        entries = line.split(\"\\t\")\n",
    "        #print in_file\n",
    "        #print entries\n",
    "        e_value = float(entries[7])\n",
    "        if e_value > e_value_threshold:\n",
    "            continue\n",
    "        best_hit = entries[8]\n",
    "        hit_names = entries[11]\n",
    "        if best_hit not in resistance_genes[cluster_name]:\n",
    "            resistance_genes[cluster_name][best_hit] = 0\n",
    "        resistance_genes[cluster_name][best_hit] += 1\n",
    "    in_file.close()\n",
    "\n",
    "#only use clusters that have both antiSMASH and CARD file\n",
    "cluster_list = [c for c in cluster_list if c in CARD_cluster_list]\n",
    "\n",
    "#write feature matrices\n",
    "CDS_motif_only_output = open(new_BGCs_dir + \"CDS_motifs.csv\",'w')\n",
    "SMCOG_only_output = open(new_BGCs_dir + \"SMCOG.csv\",'w')\n",
    "pfam_output = open(new_BGCs_dir + \"PFAM.csv\",'w')\n",
    "cluster_list_out = open(new_BGCs_dir + \"cluster_list.txt\",'w')\n",
    "pks_nrps_type_output = open(new_BGCs_dir + \"pks_nrps_type.csv\",'w')\n",
    "pk_signature_output = open(new_BGCs_dir + \"pk_signature.csv\",'w')\n",
    "pk_minowa_output = open(new_BGCs_dir + \"pk_minowa.csv\",'w')\n",
    "pk_consensus_output = open(new_BGCs_dir + \"pk_consensus.csv\",'w')\n",
    "nrp_stachelhaus_output = open(new_BGCs_dir + \"nrp_stachelhaus.csv\",'w')\n",
    "nrp_nrpspredictor_output = open(new_BGCs_dir + \"nrp_nrpspredictor.csv\",'w')\n",
    "nrp_pHMM_output = open(new_BGCs_dir + \"nrp_pHMM.csv\",'w')\n",
    "nrp_predicat_output = open(new_BGCs_dir + \"nrp_predicat.csv\",'w')\n",
    "nrp_sandpuma_output = open(new_BGCs_dir + \"nrp_sandpuma.csv\",'w')\n",
    "resistance_output = open(new_BGCs_dir + \"CARD_gene.csv\", \"w\")\n",
    "\n",
    "for cluster in cluster_list:\n",
    "    cluster_list_out.write(cluster + \"\\n\")\n",
    "    for CDS_motif in used_CDS_list:\n",
    "        if CDS_motif in CDS_motifs[cluster]:\n",
    "            CDS_motif_only_output.write(str(CDS_motifs[cluster][CDS_motif]) +\",\")\n",
    "        else:\n",
    "            CDS_motif_only_output.write(\"0,\")\n",
    "            \n",
    "    for smCOG in used_smCOG_list:\n",
    "        if smCOG in smCOGs[cluster]:\n",
    "            SMCOG_only_output.write(str(smCOGs[cluster][smCOG]) +\",\")\n",
    "        else:\n",
    "            SMCOG_only_output.write(\"0,\")\n",
    "            \n",
    "    for pfam in used_pfam_list:\n",
    "        if pfam in pfam_counts[cluster]:\n",
    "            pfam_output.write(str(pfam_counts[cluster][pfam]) +\",\")\n",
    "        else:\n",
    "            pfam_output.write(\"0,\")\n",
    "            \n",
    "    for pks_nrp_type in used_pks_nrps_type_list:\n",
    "        if pks_nrp_type in pks_nrp_subtypes[cluster]:\n",
    "            pks_nrps_type_output.write(str(pks_nrp_subtypes[cluster][pks_nrp_type]) +\",\")\n",
    "        else:\n",
    "            pks_nrps_type_output.write(\"0,\")\n",
    "            \n",
    "    for pk in used_pk_signature_list:\n",
    "        if pk in pk_monomers_signature[cluster]:\n",
    "            pk_signature_output.write(str(pk_monomers_signature[cluster][pk]) +\",\")\n",
    "        else:\n",
    "            pk_signature_output.write(\"0,\")\n",
    "        \n",
    "    for pk in used_pk_minowa_list:\n",
    "        if pk in pk_monomers_minowa[cluster]:\n",
    "            pk_minowa_output.write(str(pk_monomers_minowa[cluster][pk]) +\",\")\n",
    "        else:\n",
    "            pk_minowa_output.write(\"0,\")\n",
    "            \n",
    "    for pk in used_pk_consensus_list:\n",
    "        if pk in pk_monomers_consensus[cluster]:\n",
    "            pk_consensus_output.write(str(pk_monomers_consensus[cluster][pk]) +\",\")\n",
    "        else:\n",
    "            pk_consensus_output.write(\"0,\")\n",
    "            \n",
    "    for nrp in used_nrp_stachelhaus_list:\n",
    "        if nrp in nrp_monomers_stachelhaus[cluster]:\n",
    "            nrp_stachelhaus_output.write(str(nrp_monomers_stachelhaus[cluster][nrp]) +\",\")\n",
    "        else:\n",
    "            nrp_stachelhaus_output.write(\"0,\")\n",
    "    \n",
    "    for nrp in used_nrp_nrps_predictor_list:\n",
    "        if nrp in nrp_monomers_nrps_predictor[cluster]:\n",
    "            nrp_nrpspredictor_output.write(str(nrp_monomers_nrps_predictor[cluster][nrp]) +\",\")\n",
    "        else:\n",
    "            nrp_nrpspredictor_output.write(\"0,\")\n",
    "            \n",
    "    for nrp in used_nrp_pHMM_list:\n",
    "        if nrp in nrp_monomers_pHMM[cluster]:\n",
    "            nrp_pHMM_output.write(str(nrp_monomers_pHMM[cluster][nrp]) +\",\")\n",
    "        else:\n",
    "            nrp_pHMM_output.write(\"0,\")\n",
    "    \n",
    "    for nrp in used_nrp_predicat_list:\n",
    "        if nrp in nrp_monomers_predicat[cluster]:\n",
    "            nrp_predicat_output.write(str(nrp_monomers_predicat[cluster][nrp]) +\",\")\n",
    "        else:\n",
    "            nrp_predicat_output.write(\"0,\")\n",
    "            \n",
    "    for nrp in used_nrp_sandpuma_list:\n",
    "        if nrp in nrp_monomers_sandpuma[cluster]:\n",
    "            nrp_sandpuma_output.write(str(nrp_monomers_sandpuma[cluster][nrp]) +\",\")\n",
    "        else:\n",
    "            nrp_sandpuma_output.write(\"0,\")\n",
    "            \n",
    "    for gene in used_resistance_genes_list:\n",
    "        if cluster not in resistance_genes or gene not in resistance_genes[cluster]:\n",
    "            resistance_output.write(\"0,\")\n",
    "        else:\n",
    "            resistance_output.write(str(resistance_genes[cluster][gene])+\",\")\n",
    "        \n",
    "    CDS_motif_only_output.write('\\n')\n",
    "    SMCOG_only_output.write('\\n')\n",
    "    pfam_output.write(\"\\n\")\n",
    "    pks_nrps_type_output.write(\"\\n\")\n",
    "    pk_signature_output.write(\"\\n\")\n",
    "    pk_minowa_output.write(\"\\n\")\n",
    "    pk_consensus_output.write(\"\\n\")\n",
    "    nrp_stachelhaus_output.write(\"\\n\")\n",
    "    nrp_nrpspredictor_output.write(\"\\n\")\n",
    "    nrp_pHMM_output.write(\"\\n\")\n",
    "    nrp_predicat_output.write(\"\\n\")\n",
    "    nrp_sandpuma_output.write(\"\\n\")\n",
    "    resistance_output.write(\"\\n\")\n",
    "\n",
    "CDS_motif_only_output.close()\n",
    "pfam_output.close()\n",
    "SMCOG_only_output.close()\n",
    "cluster_list_out.close()\n",
    "    \n",
    "pks_nrps_type_output.close()\n",
    "pk_signature_output.close()\n",
    "pk_minowa_output.close()\n",
    "pk_consensus_output.close()\n",
    "nrp_stachelhaus_output.close()\n",
    "nrp_nrpspredictor_output.close()\n",
    "nrp_pHMM_output.close()\n",
    "nrp_predicat_output.close()\n",
    "nrp_sandpuma_output.close()    \n",
    "resistance_output.close()\n",
    "\n",
    "if include_SSN:\n",
    "    outfile = open(new_BGCs_dir+ \"SSN.csv\",'w')\n",
    "    included_clusters =  {}\n",
    "    for pfam_name in SSN_list:\n",
    "        base = pfam_name[0:pfam_name.rfind(\"_\")]\n",
    "        if base not in included_clusters:\n",
    "            included_clusters[base] = []\n",
    "        numbering = pfam_name[pfam_name.rfind(\"_\")+1:len(pfam_name)].replace(\"\\r\",\"\")\n",
    "        included_clusters[base].append(numbering.replace(\"\\n\",\"\"))\n",
    "        \n",
    "    for cluster in cluster_list:\n",
    "        f = new_BGCs_dir +\"antiSMASH/\" + cluster + \".gbk\"\n",
    "        test_SSN_feature_matrix = SSN_tools.generateSSNFeatureMatrix([f], SSN_pfam_names, SSN_list, included_clusters, blast_exe, cluster, \"./\")\n",
    "        row = test_SSN_feature_matrix[0,:]\n",
    "        for v in row:\n",
    "            outfile.write(str(int(v))+\",\")\n",
    "        outfile.write(\"\\n\")\n",
    "    outfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make predictions for new BGCs\n",
    "makes activity predictions for new clusters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cluster_example1:\n",
      "log: 0.6023603011537496\n",
      "svm: 0.7862790031990684\n",
      "tree: 0.82\n",
      "\n",
      "cluster_example2:\n",
      "log: 0.44172488317592107\n",
      "svm: 0.6461263786712351\n",
      "tree: 0.66\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn import preprocessing\n",
    "import readFeatureFiles\n",
    "\n",
    "#directories for input files\n",
    "features_for_predictions_dir = \"BGCs_for_prediction/\"\n",
    "outfile = open(features_for_predictions_dir + \"probability_predictions.txt\", 'w')\n",
    "\n",
    "classification = \"antibacterial\"\n",
    "#set random seed so results are consistent\n",
    "random.seed(1)\n",
    "#include features from SSN \n",
    "include_SSN = False\n",
    "\n",
    "#parameters for classifiers\n",
    "log_params = {}\n",
    "log_params[\"antibacterial\"] = {\"l1_ratio\":.05,\"alpha\":.01}\n",
    "log_params[\"antigrampos\"] = {\"l1_ratio\":.001,\"alpha\":.001}\n",
    "log_params[\"antigramneg\"] = {\"l1_ratio\":.05,\"alpha\":.001}\n",
    "log_params[\"antieuk\"] = {\"l1_ratio\":.001,\"alpha\":.001}\n",
    "log_params[\"antifungal\"] = {\"l1_ratio\":.0001,\"alpha\":.01}\n",
    "log_params[\"cytotoxic_antitumor\"] = {\"l1_ratio\":.001,\"alpha\":.001}\n",
    "\n",
    "svm_params = {}\n",
    "svm_params[\"antibacterial\"] = {\"kernel\":'rbf',\"C\":10,\"gamma\":0.1}\n",
    "svm_params[\"antigrampos\"] = {\"kernel\":'rbf',\"C\":10,\"gamma\":.01}\n",
    "svm_params[\"antigramneg\"] = {\"kernel\":'rbf',\"C\":10,\"gamma\":0.01}\n",
    "svm_params[\"antieuk\"] = {\"kernel\":'linear',\"C\":.1}\n",
    "svm_params[\"antifungal\"] = {\"kernel\":'rbf',\"C\":10,\"gamma\":0.1}\n",
    "svm_params[\"cytotoxic_antitumor\"] = {\"kernel\":'rbf',\"C\":100,\"gamma\":0.1}\n",
    "\n",
    "forest_params = {}\n",
    "forest_params[\"antibacterial\"] = {\"depth\":100,\"n\":50}\n",
    "forest_params[\"antigrampos\"] = {\"depth\":100,\"n\":50}\n",
    "forest_params[\"antigramneg\"] = {\"depth\":100,\"n\":25}\n",
    "forest_params[\"antieuk\"] = {\"depth\":None,\"n\":25}\n",
    "forest_params[\"antifungal\"] = {\"depth\":50,\"n\":50}\n",
    "forest_params[\"cytotoxic_antitumor\"] = {\"depth\":50,\"n\":100}\n",
    "\n",
    "#read in features\n",
    "pfam_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/PFAM.csv\")\n",
    "card_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/CARD_gene.csv\")\n",
    "smCOG_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/SMCOG.csv\")\n",
    "SSN_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/SSN.csv\")\n",
    "CDS_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/CDS_motifs.csv\")\n",
    "\n",
    "\n",
    "pks_nrps_type_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pks_nrps_type.csv\")\n",
    "pk_signature_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_signature.csv\")\n",
    "pk_minowa_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_minowa.csv\")\n",
    "pk_consensus_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/pk_consensus.csv\")\n",
    "\n",
    "nrp_stachelhaus_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_stachelhaus.csv\")\n",
    "nrp_nrpspredictor_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_nrpspredictor.csv\")\n",
    "nrp_pHMM_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_pHMM.csv\")\n",
    "nrp_predicat_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_predicat.csv\")\n",
    "nrp_sandpuma_features = readFeatureFiles.readFeatureMatrix(\"feature_matrices/nrp_sandpuma.csv\")\n",
    "\n",
    "#read in list of feature lables\n",
    "pfam_list = readFeatureFiles.readFeatureList(\"feature_matrices/PFAM_list.txt\")\n",
    "card_list = readFeatureFiles.readFeatureList(\"feature_matrices/CARD_gene_list.txt\")\n",
    "smCOG_list = readFeatureFiles.readFeatureList(\"feature_matrices/SMCOG_list.txt\")\n",
    "SSN_list = readFeatureFiles.readFeatureList(\"feature_matrices/SSN_list.txt\")\n",
    "CDS_list = readFeatureFiles.readFeatureList(\"feature_matrices/CDS_motifs_list.txt\")\n",
    "\n",
    "pks_nrps_type_list = readFeatureFiles.readFeatureList(\"feature_matrices/pks_nrps_type_list.txt\")\n",
    "pk_signature_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_signature_list.txt\")\n",
    "pk_minowa_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_minowa_list.txt\")\n",
    "pk_consensus_list = readFeatureFiles.readFeatureList(\"feature_matrices/pk_consensus_list.txt\")\n",
    "\n",
    "nrp_stachelhaus_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_stachelhaus_list.txt\")\n",
    "nrp_nrpspredictor_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_nrpspredictor_list.txt\")\n",
    "nrp_pHMM_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_pHMM_list.txt\")\n",
    "nrp_predicat_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_predicat_list.txt\")\n",
    "nrp_sandpuma_list = readFeatureFiles.readFeatureList(\"feature_matrices/nrp_sandpuma_list.txt\")\n",
    "\n",
    "#concatenate features\n",
    "features = np.concatenate((pfam_features, card_features), axis=1)\n",
    "features = np.concatenate((features,  smCOG_features), axis=1)\n",
    "features = np.concatenate((features,  CDS_features), axis=1)\n",
    "if include_SSN:\n",
    "    features = np.concatenate((features,  SSN_features), axis=1)\n",
    "features = np.concatenate((features,  pks_nrps_type_features), axis=1)\n",
    "features = np.concatenate((features,  pk_signature_features), axis=1)\n",
    "features = np.concatenate((features,  pk_minowa_features), axis=1)\n",
    "features = np.concatenate((features,  pk_consensus_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_stachelhaus_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_nrpspredictor_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_pHMM_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_predicat_features), axis=1)\n",
    "features = np.concatenate((features,  nrp_sandpuma_features), axis=1)\n",
    "\n",
    "feature_list = pfam_list +card_list+smCOG_list+CDS_list+SSN_list+pks_nrps_type_list+pk_signature_list+pk_minowa_list+pk_consensus_list+nrp_stachelhaus_list+nrp_nrpspredictor_list+nrp_pHMM_list+nrp_predicat_list+nrp_sandpuma_list\n",
    "\n",
    "is_antibacterial = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_antibacterial.csv\")\n",
    "is_antifungal = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_antifungal.csv\")\n",
    "is_cytotoxic = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_cytotoxic.csv\")\n",
    "is_unknown = readFeatureFiles.readClassesMatrix(\"feature_matrices/is_unknown.csv\")\n",
    "targets_gram_pos = readFeatureFiles.readClassesMatrix(\"feature_matrices/targets_gram_pos.csv\")\n",
    "targets_gram_neg = readFeatureFiles.readClassesMatrix(\"feature_matrices/targets_gram_neg.csv\")\n",
    "full_cluster_list = readFeatureFiles.readClusterList(\"feature_matrices/cluster_list_CARD.txt\")\n",
    "is_not_unknown_indices = readFeatureFiles.getNotUnknownIndices(is_unknown)\n",
    "target_unannotated = is_antibacterial*((targets_gram_pos+targets_gram_neg)<1)\n",
    "is_not_unknown_indices_gram =  readFeatureFiles.getNotUnknownIndices(is_unknown + target_unannotated)\n",
    "\n",
    "is_antibacterial = (is_antibacterial >= 1).astype(int)\n",
    "is_antieuk = ((is_antifungal + is_cytotoxic)>=1).astype(int)\n",
    "is_gram_pos = (targets_gram_pos >= 1).astype(int)\n",
    "is_gram_neg = (targets_gram_neg >= 1).astype(int)\n",
    "\n",
    "y_vars = []\n",
    "if classification == \"antibacterial\":\n",
    "    y_vars = is_antibacterial\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "    \n",
    "if classification == \"antieuk\":\n",
    "    y_vars = is_antieuk\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "\n",
    "    \n",
    "if classification == \"antifungal\":\n",
    "    y_vars = (is_antifungal >= 1).astype(int)\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "    \n",
    "if classification == \"cytotoxic_antitumor\":\n",
    "    y_vars = (is_cytotoxic >= 1).astype(int)\n",
    "    y_vars = y_vars[is_not_unknown_indices]\n",
    "    features = features[is_not_unknown_indices,:]\n",
    "    \n",
    "if classification == \"antigramneg\":\n",
    "    y_vars = is_gram_neg\n",
    "    y_vars = y_vars[is_not_unknown_indices_gram]\n",
    "    features = features[is_not_unknown_indices_gram,:]\n",
    "    \n",
    "if classification == \"antigrampos\":\n",
    "    y_vars = is_gram_pos\n",
    "    y_vars = y_vars[is_not_unknown_indices_gram]\n",
    "    features = features[is_not_unknown_indices_gram,:]\n",
    "\n",
    "#train classifiers\n",
    "min_max_scaler = preprocessing.MinMaxScaler()\n",
    "scaled_training_x = min_max_scaler.fit_transform(features)\n",
    "opt_log_params = log_params[classification]\n",
    "log_classifier = SGDClassifier(loss='log',penalty='elasticnet',max_iter=100,alpha=opt_log_params[\"alpha\"],l1_ratio=opt_log_params[\"l1_ratio\"],tol=None)\n",
    "opt_svm_params = svm_params[classification]\n",
    "if opt_svm_params['kernel'] == \"linear\":\n",
    "    svm_classifier = SVC(kernel=\"linear\",C=opt_svm_params[\"C\"], probability=True)\n",
    "else:\n",
    "    svm_classifier = SVC(kernel=\"rbf\",C=opt_svm_params[\"C\"], gamma=opt_svm_params[\"gamma\"], probability=True)\n",
    "    \n",
    "opt_forest_params = forest_params[classification]\n",
    "tree_classifier = ExtraTreesClassifier(bootstrap=True,max_features=\"auto\",n_estimators=opt_forest_params[\"n\"], max_depth=opt_forest_params[\"depth\"], random_state=0)\n",
    "\n",
    "log_classifier.fit(scaled_training_x, y_vars)\n",
    "svm_classifier.fit(scaled_training_x, y_vars)\n",
    "tree_classifier.fit(features, y_vars)\n",
    "\n",
    "#read features for new predictions\n",
    "new_cluster_list = readFeatureFiles.readClusterList(features_for_predictions_dir + \"cluster_list.txt\")\n",
    "new_pfam_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"PFAM.csv\")\n",
    "new_card_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"CARD_gene.csv\")\n",
    "new_smCOG_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"SMCOG.csv\")\n",
    "if include_SSN:\n",
    "    new_SSN_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"SSN.csv\")\n",
    "new_CDS_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"CDS_motifs.csv\")\n",
    "\n",
    "\n",
    "new_pks_nrps_type_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"pks_nrps_type.csv\")\n",
    "new_pk_signature_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"pk_signature.csv\")\n",
    "new_pk_minowa_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"pk_minowa.csv\")\n",
    "new_pk_consensus_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"pk_consensus.csv\")\n",
    "\n",
    "new_nrp_stachelhaus_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"nrp_stachelhaus.csv\")\n",
    "new_nrp_nrpspredictor_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"nrp_nrpspredictor.csv\")\n",
    "new_nrp_pHMM_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"nrp_pHMM.csv\")\n",
    "new_nrp_predicat_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"nrp_predicat.csv\")\n",
    "new_nrp_sandpuma_features = readFeatureFiles.readFeatureMatrix(features_for_predictions_dir + \"nrp_sandpuma.csv\")\n",
    "\n",
    "\n",
    "#concatenate features\n",
    "new_features = np.concatenate((new_pfam_features, new_card_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_smCOG_features), axis=1)\n",
    "new_features = np.concatenate((new_features, new_CDS_features), axis=1)\n",
    "if include_SSN:\n",
    "    new_features = np.concatenate((new_features,  new_SSN_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_pks_nrps_type_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_pk_signature_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_pk_minowa_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_pk_consensus_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_nrp_stachelhaus_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_nrp_nrpspredictor_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_nrp_pHMM_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_nrp_predicat_features), axis=1)\n",
    "new_features = np.concatenate((new_features,  new_nrp_sandpuma_features), axis=1)\n",
    "\n",
    "#make predictions\n",
    "scaled_new_x = min_max_scaler.transform(new_features)\n",
    "log_probabilities = log_classifier.predict_proba(scaled_new_x)\n",
    "svm_probabilities = svm_classifier.predict_proba(scaled_new_x)\n",
    "tree_probabilities = tree_classifier.predict_proba(new_features)\n",
    "\n",
    "#write and print results\n",
    "i = 0\n",
    "for c in new_cluster_list:\n",
    "    outfile.write(c + \",\")\n",
    "    outfile.write(str(log_probabilities[i][1]) + \",\")\n",
    "    outfile.write(str(svm_probabilities[i][1]) + \",\")\n",
    "    outfile.write(str(tree_probabilities[i][1]) + \",\")\n",
    "    outfile.write(\"\\n\")\n",
    "    \n",
    "    print(c + \":\")\n",
    "    print(\"log: \" + str(log_probabilities[i][1]))\n",
    "    print(\"svm: \" + str(svm_probabilities[i][1]))\n",
    "    print(\"tree: \" + str(tree_probabilities[i][1]))\n",
    "    print(\"\")\n",
    "    i += 1\n",
    "outfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Knowncluster blast score analysis\n",
    "extracts knownclusterblast from antiSMASH output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "cluster_list_file = open(\"holdout_set/training_cluster_list.txt\") #file with list of training clusters\n",
    "\n",
    "#read list of training clusters\n",
    "training_clusters = []\n",
    "for line in cluster_list_file:\n",
    "    cluster_name = line.replace(\"\\n\",\"\")\n",
    "    cluster_name = cluster_name.replace(\"\\r\",\"\")\n",
    "    cluster_name = cluster_name.replace(\"\\t\",\"\")\n",
    "    if cluster_name[-2] == \"_\":\n",
    "        cluster_name = cluster_name[0:len(cluster_name)-2]\n",
    "    elif cluster_name[-3] == \"_\":\n",
    "        cluster_name = cluster_name[0:len(cluster_name)-3]\n",
    "    training_clusters.append(cluster_name.replace(\"_\",\" \"))\n",
    "\n",
    "#read knownclusterblast outputs from antismash results\n",
    "cluster_files = []\n",
    "no_antismash_result = []\n",
    "for f in os.listdir(\"./holdout_set/antismash_knownclusterblast\"):\n",
    "    found_cluster = False\n",
    "    for f2 in os.listdir(\"./holdout_set/antismash_knownclusterblast/\" + f):\n",
    "        if \"cluster001.gbk\" in f2:\n",
    "            cluster_files.append(\"./holdout_set/antismash_knownclusterblast/\" + f + \"/svg/knownclusterblast1_all.svg\")\n",
    "            found_cluster = True\n",
    "    if not found_cluster:\n",
    "        no_antismash_result.append(f)\n",
    "            \n",
    "#read knownclusterblast results from html file\n",
    "top_hit = {}\n",
    "for f in cluster_files:\n",
    "    cluster_name = f[f.find(\"antismash_knownclusterblast/\")+len(\"antismash_knownclusterblast/\"):f.rfind(\"/svg\")]\n",
    "    if os.path.isfile(f):\n",
    "        in_file = open(f)\n",
    "        for line in in_file:\n",
    "            if 'clusterblast-cluster' in line:\n",
    "                for c in training_clusters:\n",
    "                    if c.lower() in line.lower():\n",
    "                        percent_sim = line[0:line.find(\"of genes show similarity\")]\n",
    "                        percent_sim = percent_sim[percent_sim.rfind(\"(\")+1:percent_sim.find(\"%\")]\n",
    "                        if cluster_name not in top_hit:\n",
    "                            top_hit[cluster_name] = int(percent_sim)\n",
    "                        elif int(percent_sim) > top_hit[cluster_name]: \n",
    "                            top_hit[cluster_name] = int(percent_sim)\n",
    "        if cluster_name not in top_hit:\n",
    "            top_hit[cluster_name] = 0\n",
    "    else:\n",
    "        top_hit[cluster_name] = 0\n",
    "\n",
    "#write bin files\n",
    "no_cluster = open(\"holdout_set/knownclusterblast_bins/did_not_find_cluster.txt\", 'w')\n",
    "for c in no_antismash_result:\n",
    "    no_cluster.write(c + \"\\n\")\n",
    "no_hits = open(\"holdout_set/knownclusterblast_bins/no_hits.txt\", 'w')\n",
    "bin1 = open(\"holdout_set/knownclusterblast_bins/hits_range_0_25.txt\", 'w')\n",
    "bin2 = open(\"holdout_set/knownclusterblast_bins/hits_range_25_50.txt\", 'w')\n",
    "bin3 = open(\"holdout_set/knownclusterblast_bins/hits_range_50_75.txt\", 'w')\n",
    "bin4 = open(\"holdout_set/knownclusterblast_bins/hits_range_75_100.txt\", 'w')\n",
    "for c in top_hit:\n",
    "    if top_hit[c] == 0:\n",
    "        no_hits.write(c + \"\\n\")\n",
    "    elif top_hit[c] > 0 and top_hit[c] <= 25:\n",
    "        bin1.write(c + \"\\n\")\n",
    "    elif top_hit[c] > 25 and top_hit[c] <= 50:\n",
    "        bin2.write(c + \"\\n\")\n",
    "    elif top_hit[c] > 50 and top_hit[c] <= 75:\n",
    "        bin3.write(c + \"\\n\")\n",
    "    elif top_hit[c] > 75 and top_hit[c] <= 100:\n",
    "        bin4.write(c + \"\\n\")\n",
    "\n",
    "no_cluster.close()\n",
    "no_hits.close()\n",
    "bin1.close()\n",
    "bin2.close()\n",
    "bin3.close()\n",
    "bin4.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Holdout set analysis\n",
    "predictions of holdout activity were made using the command line script also included on our github page. This calculates the accuracy of predictions for subsets of the holdout set with different knownclusterblast score with clusters in the training set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import balanced_accuracy_score\n",
    "import readFeatureFiles\n",
    "import numpy as np\n",
    "\n",
    "prediction_threshold  = 0.5 #threshold to predict as active\n",
    "\n",
    "def readClassification(filename):\n",
    "    in_file = open(filename)\n",
    "    classification = []\n",
    "    for line in in_file:\n",
    "        classification.append(int(line))\n",
    "    in_file.close()\n",
    "    return np.array(classification)\n",
    "\n",
    "def readPredictionFile(filename):\n",
    "    in_file = open(filename)\n",
    "    probabilities = []\n",
    "    for line in in_file:\n",
    "        if \"probabilities\" in line:\n",
    "            continue\n",
    "        split_line = line.split(\" \")\n",
    "        probabilities.append(float(split_line[2]))\n",
    "        probabilities.append(float(split_line[6]))\n",
    "        probabilities.append(float(split_line[9]))\n",
    "    in_file.close()\n",
    "    return probabilities\n",
    "\n",
    "\n",
    "#read holdout clusters\n",
    "cluster_list_in = open(\"holdout_set/classifications/cluster_list.txt\", 'r')\n",
    "cluster_list = []\n",
    "for line in cluster_list_in:\n",
    "    cluster_list.append(line.replace(\"\\n\",\"\"))\n",
    "cluster_list_in.close()\n",
    "\n",
    "#read true holdout classifications\n",
    "is_unknown = readClassification(\"holdout_set/classifications/is_unknown.csv\")\n",
    "is_antibacterial = readClassification(\"holdout_set/classifications/is_antibacterial.csv\")\n",
    "targets_gram_pos = readClassification(\"holdout_set/classifications/targets_gram_pos.csv\")\n",
    "targets_gram_neg = readClassification(\"holdout_set/classifications/targets_gram_neg.csv\")\n",
    "is_antifungal = readClassification(\"holdout_set/classifications/is_antifungal.csv\")\n",
    "is_cytotoxic = readClassification(\"holdout_set/classifications/is_cytotoxic.csv\")\n",
    "\n",
    "is_not_unknown_indices = readFeatureFiles.getNotUnknownIndices(is_unknown)\n",
    "target_unannotated = is_antibacterial*((targets_gram_pos+targets_gram_neg)<1)\n",
    "is_not_unknown_indices_gram =  readFeatureFiles.getNotUnknownIndices(is_unknown + target_unannotated)\n",
    "\n",
    "is_antibacterial = (is_antibacterial >= 1).astype(int)\n",
    "is_antieuk = ((is_antifungal + is_cytotoxic)>=1).astype(int)\n",
    "is_gram_pos = (targets_gram_pos >= 1).astype(int)\n",
    "is_gram_neg = (targets_gram_neg >= 1).astype(int)\n",
    "is_antifungal_cytotoxic= (is_antifungal + is_cytotoxic >= 1).astype(int)\n",
    "\n",
    "#remove clusters with unknown function\n",
    "cluster_list_original = cluster_list\n",
    "new_cluster_list = []\n",
    "for i in is_not_unknown_indices:\n",
    "    new_cluster_list.append(cluster_list[i])\n",
    "cluster_list = new_cluster_list\n",
    "is_antibacterial = is_antibacterial[is_not_unknown_indices]\n",
    "is_antifungal = is_antifungal[is_not_unknown_indices]\n",
    "is_cytotoxic = is_cytotoxic[is_not_unknown_indices]\n",
    "is_antifungal_cytotoxic = is_antifungal_cytotoxic[is_not_unknown_indices]\n",
    "\n",
    "#make separate gram pos gram neg list\n",
    "new_cluster_list = []\n",
    "for i in is_not_unknown_indices_gram:\n",
    "    new_cluster_list.append(cluster_list_original[i])\n",
    "cluster_list_targets = new_cluster_list\n",
    "is_gram_pos = is_gram_pos[is_not_unknown_indices_gram]\n",
    "is_gram_neg = is_gram_neg[is_not_unknown_indices_gram]\n",
    "\n",
    "#read probabilities\n",
    "tree_antibac_prob = []\n",
    "svm_antibac_prob  = []\n",
    "log_antibac_prob = []\n",
    "\n",
    "tree_antipos_prob = []\n",
    "svm_antipos_prob = []\n",
    "log_antipos_prob = []\n",
    "\n",
    "tree_antineg_prob = []\n",
    "svm_antineg_prob = []\n",
    "log_antineg_prob = []\n",
    "\n",
    "tree_antifungal_prob = []\n",
    "svm_antifungal_prob = []\n",
    "log_antifungal_prob = []\n",
    "\n",
    "tree_cytotoxic_prob = []\n",
    "svm_cytotoxic_prob = []\n",
    "log_cytotoxic_prob = []\n",
    "\n",
    "tree_cytotoxic_antifungal_prob = []\n",
    "svm_cytotoxic_antifungal_prob = []\n",
    "log_cytotoxic_antifungal_prob = []\n",
    "\n",
    "for c in cluster_list:\n",
    "    probs = readPredictionFile(\"holdout_set/activity_predictions/\" + c + \".txt\")\n",
    "    tree_antibac_prob.append(probs[0])\n",
    "    log_antibac_prob.append(probs[1])\n",
    "    svm_antibac_prob.append(probs[2])\n",
    "    \n",
    "    tree_cytotoxic_antifungal_prob.append(probs[9])\n",
    "    log_cytotoxic_antifungal_prob.append(probs[10])\n",
    "    svm_cytotoxic_antifungal_prob.append(probs[11])\n",
    "    \n",
    "    tree_antifungal_prob.append(probs[12])\n",
    "    log_antifungal_prob.append(probs[13])\n",
    "    svm_antifungal_prob.append(probs[14])\n",
    "    \n",
    "    tree_cytotoxic_prob.append(probs[15])\n",
    "    log_cytotoxic_prob.append(probs[16])\n",
    "    svm_cytotoxic_prob.append(probs[17])\n",
    "    \n",
    "for c in cluster_list_targets:\n",
    "    probs = readPredictionFile(\"holdout_set/activity_predictions/\" + c + \".txt\")\n",
    "    tree_antipos_prob.append(probs[3])\n",
    "    log_antipos_prob.append(probs[4])\n",
    "    svm_antipos_prob.append(probs[5])\n",
    "    \n",
    "    tree_antineg_prob.append(probs[6])\n",
    "    log_antineg_prob.append(probs[7])\n",
    "    svm_antineg_prob.append(probs[8])\n",
    "\n",
    "tree_antibac_prediction = (np.array(tree_antibac_prob) >= prediction_threshold).astype(int)\n",
    "log_antibac_prediction = (np.array(log_antibac_prob) >= prediction_threshold).astype(int)\n",
    "svm_antibac_prediction = (np.array(svm_antibac_prob) >= prediction_threshold).astype(int)\n",
    "\n",
    "tree_antipos_prediction = (np.array(tree_antipos_prob) >= prediction_threshold).astype(int)\n",
    "log_antipos_prediction = (np.array(log_antipos_prob) >= prediction_threshold).astype(int)\n",
    "svm_antipos_prediction = (np.array(svm_antipos_prob) >= prediction_threshold).astype(int)\n",
    "\n",
    "tree_antineg_prediction = (np.array(tree_antineg_prob) >= prediction_threshold).astype(int)\n",
    "log_antineg_prediction = (np.array(log_antineg_prob) >= prediction_threshold).astype(int)\n",
    "svm_antineg_prediction = (np.array(svm_antineg_prob) >= prediction_threshold).astype(int)\n",
    "\n",
    "tree_cytotoxic_antifungal_prediction = (np.array(tree_cytotoxic_antifungal_prob) >= prediction_threshold).astype(int)\n",
    "log_cytotoxic_antifungal_prediction = (np.array(log_cytotoxic_antifungal_prob) >= prediction_threshold).astype(int)\n",
    "svm_cytotoxic_antifungal_prediction = (np.array(svm_cytotoxic_antifungal_prob) >= prediction_threshold).astype(int)\n",
    "\n",
    "tree_antifungal_prediction = (np.array(tree_antifungal_prob) >= prediction_threshold).astype(int)\n",
    "log_antifungal_prediction = (np.array(log_antifungal_prob) >= prediction_threshold).astype(int)\n",
    "svm_antifungal_prediction = (np.array(svm_antifungal_prob) >= prediction_threshold).astype(int)\n",
    "\n",
    "tree_cytotoxic_prediction = (np.array(tree_cytotoxic_prob) >= prediction_threshold).astype(int)\n",
    "log_cytotoxic_prediction = (np.array(log_cytotoxic_prob) >= prediction_threshold).astype(int)\n",
    "svm_cytotoxic_prediction = (np.array(svm_cytotoxic_prob) >= prediction_threshold).astype(int)\n",
    "\n",
    "holdout_bins = [\"did_not_find_cluster\", \"no_hits\", \"hits_range_0_25\",\"hits_range_25_50\",\"hits_range_50_75\",\"hits_range_75_100\"]\n",
    "\n",
    "for b in holdout_bins:\n",
    "    outfile = open(\"holdout_set/\" + b + \"_balanced_accuracy.txt\", 'w')\n",
    "    infile = open(\"holdout_set/knownclusterblast_bins/\" + b  +\".txt\")\n",
    "    in_subset_index = []\n",
    "    in_subset_cluster = []\n",
    "    in_subset_index_target = []\n",
    "    for line in infile:\n",
    "        in_subset_cluster.append(line.replace(\"\\n\",\"\"))\n",
    "    \n",
    "    #get indices for clusters in the subset\n",
    "    for i in range(0, len(cluster_list)):\n",
    "        c = cluster_list[i]\n",
    "        if c in in_subset_cluster:\n",
    "            in_subset_index.append(i)\n",
    "        \n",
    "        \n",
    "    for i in range(0, len(cluster_list_targets)):\n",
    "        c = cluster_list_targets[i]\n",
    "        if c in in_subset_cluster:\n",
    "            in_subset_index_target.append(i)\n",
    "       \n",
    "    in_antibac_prediction_log = log_antibac_prediction[in_subset_index]\n",
    "    in_antibac_prediction_svm = svm_antibac_prediction[in_subset_index]        \n",
    "    in_antibac_prediction_tree = tree_antibac_prediction[in_subset_index]\n",
    "    in_is_antibacterial = is_antibacterial[in_subset_index]\n",
    "\n",
    "    in_antipos_prediction_log = log_antipos_prediction[in_subset_index_target]\n",
    "    in_antipos_prediction_svm = svm_antipos_prediction[in_subset_index_target]\n",
    "    in_antipos_prediction_tree = tree_antipos_prediction[in_subset_index_target]\n",
    "    in_anitpos = is_gram_pos[in_subset_index_target]\n",
    "\n",
    "    in_antineg_prediction_log = log_antineg_prediction[in_subset_index_target]\n",
    "    in_antineg_prediction_svm = svm_antineg_prediction[in_subset_index_target]\n",
    "    in_antineg_prediction_tree = tree_antineg_prediction[in_subset_index_target]\n",
    "    in_antineg = is_gram_neg[in_subset_index_target]\n",
    "\n",
    "    in_cytotoxic_antifungal_log = log_cytotoxic_antifungal_prediction[in_subset_index]\n",
    "    in_cytotoxic_antifungal_svm = svm_cytotoxic_antifungal_prediction[in_subset_index]\n",
    "    in_cytotoxic_antifungal_tree = tree_cytotoxic_antifungal_prediction[in_subset_index]\n",
    "    in_is_cytotixic_antifungal = is_antifungal_cytotoxic[in_subset_index]\n",
    "\n",
    "    in_cytotoxic_log = log_cytotoxic_prediction[in_subset_index]\n",
    "    in_cytotoxic_svm = svm_cytotoxic_prediction[in_subset_index]\n",
    "    in_cytotoxic_tree = tree_cytotoxic_prediction[in_subset_index]\n",
    "    in_is_cytotoxic = is_cytotoxic[in_subset_index]\n",
    "\n",
    "    in_antifungal_log = log_antifungal_prediction[in_subset_index]\n",
    "    in_antifungal_svm = svm_antifungal_prediction[in_subset_index]\n",
    "    in_antifungal_tree = tree_antifungal_prediction[in_subset_index]\n",
    "    in_is_antifungal = is_antifungal[in_subset_index]\n",
    "    \n",
    "    outfile.write(\"antibac \\n\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_antibacterial, in_antibac_prediction_log)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_antibacterial, in_antibac_prediction_svm)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_antibacterial, in_antibac_prediction_tree)) + \"\\n\")\n",
    "\n",
    "    outfile.write(\"antipos \\n\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_anitpos, in_antipos_prediction_log)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_anitpos, in_antipos_prediction_svm)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_anitpos, in_antipos_prediction_tree)) + \"\\n\")\n",
    "\n",
    "    outfile.write(\"antineg \\n\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_antineg, in_antineg_prediction_log)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_antineg, in_antineg_prediction_svm)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_antineg, in_antineg_prediction_tree)) + \"\\n\")\n",
    "\n",
    "    outfile.write(\"antieuk \\n\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_cytotixic_antifungal, in_cytotoxic_antifungal_log)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_cytotixic_antifungal, in_cytotoxic_antifungal_svm)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_cytotixic_antifungal, in_cytotoxic_antifungal_tree)) + \"\\n\")\n",
    "\n",
    "    outfile.write(\"antifungal \\n\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_antifungal, in_antifungal_log)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_antifungal, in_antifungal_svm)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_antifungal, in_antifungal_tree)) + \"\\n\")\n",
    "\n",
    "    outfile.write(\"cytotox \\n\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_cytotoxic, in_cytotoxic_log)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_cytotoxic, in_cytotoxic_svm)) + \",\")\n",
    "    outfile.write(str(balanced_accuracy_score(in_is_cytotoxic, in_cytotoxic_tree)) + \"\\n\")\n",
    "\n",
    "    outfile.close()\n",
    "    "
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}