init commit

Author: jhammelm

Diff for: CNN.py

@@ -0,0 +1,78 @@
+import keras 
+import numpy as np
+from keras.models import Model, load_model, Sequential
+from keras.layers import Conv1D, Dense, Reshape, Dropout, LSTM, GlobalMaxPooling1D, MaxPooling1D, Flatten, Input, Concatenate
+import tensorflow as tf
+from keras import optimizers
+
+class CNN():
+    def __init__(self,model_layers,seq_shape,out_shape=2,conv_filter_number=100,conv_filter_size=20):
+        model=Sequential()
+        for i, layer in enumerate(model_layers):
+            if layer == 'conv':
+                if i == 0:
+                    JASPAR_motifs = list(np.load('homer_matrix.npy'))
+                    filter_len = max([JASPAR_motifs[k].shape[0] for k in range(len(JASPAR_motifs))])
+                    conv_layer = Conv1D(input_shape=seq_shape,
+                                        filters=len(JASPAR_motifs)*2,
+                                        kernel_size=35,
+                                        padding="valid",
+                                        activation="relu",
+                                        strides=1)
+                    model.add(conv_layer)
+                    conv_weights = conv_layer.get_weights()
+
+                    reverse_motifs = [JASPAR_motifs[j][::-1,::-1] for j in range(len(JASPAR_motifs))]
+                    JASPAR_motifs = JASPAR_motifs + reverse_motifs
+
+                    for j in range(len(JASPAR_motifs)):
+                            m = JASPAR_motifs[j][::-1,:]
+                            w = m.shape[0]
+                            conv_weights[0][:,:,j] = 0
+                            start = np.random.randint(low=3, high=35-w-3+1)
+                            conv_weights[0][start:(start+w),:,j] = m - 0.25
+                            conv_weights[1][j] = np.random.uniform(low=-1.0,high=0.0)
+
+                    conv_layer.set_weights(conv_weights)
+                    conv_layer.trainable=False
+                else:
+                    model.add(Conv1D(conv_filter_number,conv_filter_size,activation='relu',padding='same'))
+            if layer == 'globalpool':
+                model.add(GlobalMaxPooling1D())
+            if layer == 'maxpool':
+                model.add(MaxPooling1D(3,1))
+            if layer == 'LSTM':
+                model.add(LSTM(16,return_sequences=True))
+            if layer == 'dense':
+                model.add(Dropout(0.1))
+                model.add(Dense(128,activation='relu'))
+            
+        if 'dense' not in model_layers and 'globalpool' not in model_layers:
+            model.add(Flatten())
+        model.add(Dropout(0.1))
+        model.add(Dense(out_shape,activation='sigmoid'))
+        adam = optimizers.Adam(lr=1e-4,clipnorm=0.5,decay=(1e-4/100.0))
+        model.compile(optimizer=adam,loss='binary_crossentropy',metrics=['accuracy'])
+        self.model = model
+
+    def train(self,X,y,sample_weights):
+        callbacks = [keras.callbacks.EarlyStopping(monitor='val_loss', 
+                                                   patience=3),
+                     keras.callbacks.History()]
+        history = self.model.fit(x=X,
+                                 y=y,epochs=100,
+                                 shuffle=True,
+                                 validation_split=0.2,
+                                 batch_size=100,verbose=1,
+                                 callbacks=callbacks,
+                                 sample_weight = sample_weights)
+        return history
+
+    def save(self,h5file):
+        self.model.save(h5file)
+
+    def predict(self,X):
+        return self.model.predict(X)
+
+    def error(self,X,y):
+        return np.linalg.norm(y-self.model.predict(X))

Diff for: CNN_param.py

@@ -0,0 +1,84 @@
+import keras 
+import numpy as np
+from keras.models import Model, load_model, Sequential
+from keras.layers import Conv1D, Dense, Reshape, Dropout, LSTM, GlobalMaxPooling1D, MaxPooling1D, Flatten, Input, Concatenate
+import tensorflow as tf
+from keras import optimizers
+
+class CNN():
+    def __init__(self,model_layers,seq_shape,
+                 conv_filter_number=100,
+                 conv_filter_size=20,
+                 learning_rate=1e-4,
+                 dense_size=128,
+                 dropout=0.1,
+                 batch_size=32):
+        model=Sequential()
+        for i, layer in enumerate(model_layers):
+            if layer == 'conv':
+                if i == 0:
+                    JASPAR_motifs = list(np.load('homer_matrix.npy'))
+                    filter_len = max([JASPAR_motifs[k].shape[0] for k in range(len(JASPAR_motifs))])
+                    conv_layer = Conv1D(input_shape=seq_shape,
+                                        filters=len(JASPAR_motifs)*2,
+                                        kernel_size=35,
+                                        padding="valid",
+                                        activation="relu",
+                                        strides=1)
+                    model.add(conv_layer)
+                    conv_weights = conv_layer.get_weights()
+
+                    reverse_motifs = [JASPAR_motifs[j][::-1,::-1] for j in range(len(JASPAR_motifs))]
+                    JASPAR_motifs = JASPAR_motifs + reverse_motifs
+
+                    for j in range(len(JASPAR_motifs)):
+                            m = JASPAR_motifs[j][::-1,:]
+                            w = m.shape[0]
+                            conv_weights[0][:,:,j] = 0
+                            start = np.random.randint(low=3, high=35-w-3+1)
+                            conv_weights[0][start:(start+w),:,j] = m - 0.25
+                            conv_weights[1][j] = np.random.uniform(low=-1.0,high=0.0)
+
+                    conv_layer.set_weights(conv_weights)
+                    conv_layer.trainable=False
+                else:
+                    model.add(Conv1D(conv_filter_number,conv_filter_size,activation='relu',padding='same'))
+            if layer == 'globalpool':
+                model.add(GlobalMaxPooling1D())
+            if layer == 'maxpool':
+                model.add(MaxPooling1D(3,1))
+            if layer == 'LSTM':
+                model.add(LSTM(16,return_sequences=True))
+            if layer == 'dense':
+                model.add(Dropout(dropout))
+                model.add(Dense(dense_size,activation='relu'))
+            
+        model.add(Dropout(dropout))
+        model.add(Dense(2,activation='sigmoid'))
+        adam = optimizers.Adam(lr=learning_rate)
+        model.compile(optimizer=adam,loss='binary_crossentropy',metrics=['accuracy'])
+        self.model = model
+        self.batch_size=batch_size
+
+    def train(self,X,y,sample_weights):
+        callbacks = [keras.callbacks.EarlyStopping(monitor='val_loss', 
+                                                   patience=3),
+                     keras.callbacks.History()]
+        history = self.model.fit(x=X,
+                                 y=y,epochs=100,
+                                 shuffle=True,
+                                 validation_split=0.2,
+                                 batch_size=self.batch_size,
+                                 verbose=1,
+                                 callbacks=callbacks,
+                                 sample_weight = sample_weights)
+        return history
+
+    def save(self,h5file):
+        self.model.save(h5file)
+
+    def predict(self,X):
+        return self.model.predict(X)
+
+    def error(self,X,y):
+        return np.linalg.norm(y-self.model.predict(X))

Diff for: README.md

@@ -0,0 +1 @@
+# ensemble-cnn

Diff for: __pycache__/CNN.cpython-37.pyc

@@ -0,0 +1,35 @@
+import os
+import numpy as np 
+
+def ensure_dir(file_path):
+    #directory = os.path.dirname(file_path)
+    if not os.path.exists(file_path):
+        os.makedirs(file_path)
+
+def act_to_class(act):
+    y = []
+    header = True
+    for line in open(act):
+        if header:
+            header = False
+            continue
+        data  = line.strip().split()
+        y.append([int(d) for d in data[1:]])
+    return np.array(y)
+
+def fa_to_onehot(fa):
+    alpha = ['A','C','G','T']
+    sequences = open(fa).read().split(">")[1:]
+    seqdict = [seq.strip().split("\n")[1] for seq in sequences]
+    seq_mat = []
+    slen = max([len(seq) for seq in seqdict])
+    for i,seqc in enumerate(seqdict):
+        seq = np.zeros((slen,4))
+        for j,c in enumerate(seqc.upper()):
+            if c not in alpha:
+                seq[j,:] = 0.25
+            else:
+                aind = alpha.index(c)
+                seq[j,aind] = 1
+        seq_mat.append(seq)
+    return np.array(seq_mat)

Diff for: __pycache__/ensemble_utils.cpython-37.pyc

@@ -0,0 +1,89 @@
+#!/bin/env python
+import numpy as np
+import pickle
+import argparse
+from scipy.stats import norm
+from sklearn.cluster import AffinityPropagation
+from sklearn.metrics import silhouette_score
+from sklearn import metrics
+
+parser = argparse.ArgumentParser()
+parser.add_argument('fasta')
+parser.add_argument('importance')
+parser.add_argument('-n','--ntop',default=25,type=int)
+parser.add_argument('-k','--kmer',default=10,type=int)
+parser.add_argument('-p','--pval',default=0.01,type=float,help='FDR corrected pval threshold')
+opts = parser.parse_args()
+
+seqs = [l.strip().split()[1] for l in open(opts.fasta).read().split(">")[1:]]
+with open(opts.importance,'rb') as f:
+    mat = pickle.load(f)
+
+windows = np.array([np.mean(mat[i,j:(j+opts.kmer),:]) for i in range(len(seqs)) for j in range(len(seqs[0])-opts.kmer)])
+
+mu_window = np.mean(windows)
+sigma_window = np.std(windows)
+significant_seqs =  {}
+significant_pvals = {}
+nhypothesis = windows.shape[0]
+for i in range(len(seqs)):
+    for j in range(len(seqs[0])-opts.kmer):
+        score=np.mean(mat[i,j:(j+opts.kmer)])
+        pval = norm.sf(score,
+                       loc=mu_window,scale=sigma_window)
+        if pval < opts.pval/(nhypothesis):
+            try:
+                key = significant_seqs[seqs[i][j:j+opts.kmer].upper()]
+                old_pval = significant_pvals[seqs[i][j:j+opts.kmer].upper()]
+                pval = min(pval,old_pval)
+            except KeyError:
+                significant_seqs[seqs[i][j:j+opts.kmer].upper()] = np.zeros((opts.kmer,4))
+            significant_pvals[seqs[i][j:j+opts.kmer].upper()] = pval
+            significant_seqs[seqs[i][j:j+opts.kmer].upper()] += mat[i,j:j+opts.kmer,:]
+            
+print "# num significant:",len(significant_pvals)
+
+from Bio import pairwise2
+subseqs = significant_pvals.keys()
+affinity = np.zeros((len(subseqs),len(subseqs)))
+for i in range(len(subseqs)-1):
+    for j in range(i,len(subseqs)):
+       aln = pairwise2.align.localms(subseqs[i],subseqs[j], 2, -1, -3, -1)
+       if len(aln) > 0:
+           score = aln[0][2]
+       else:
+           score = 0.01
+       affinity[i,j] = max(score,0.01)
+       affinity[j,i] = max(score,0.01)
+bestdf=0.8
+bestscore=None
+sig_subtract=None
+for ss in np.linspace(10,100,10):
+    significance=[-np.log10(1.0/1000000+ significant_pvals[k])-ss for k in subseqs]
+    labels = AffinityPropagation(damping=bestdf,affinity='precomputed',preference=significance).fit_predict(affinity)
+    score = silhouette_score(affinity, labels, metric='precomputed')
+    if bestscore != None and score > bestscore:
+        bestscore=score
+        sig_subtract=ss
+    elif bestscore == None:
+        bestscore=score
+        sig_subtract = ss
+
+significance=[-np.log10(1.0/1000000+ significant_pvals[k])-sig_subtract for k in subseqs]
+aclust = AffinityPropagation(damping=bestdf,affinity='precomputed',preference=significance).fit(affinity)
+representatives = [subseqs[i] for i in aclust.cluster_centers_indices_]
+print "# affinity clustering damping:",bestdf
+print "# affinity preference:",sig_subtract
+print "# num clusters:",len(representatives)
+print "# silhouette coefficient:",bestscore
+sorted_significant = sorted([(k,significant_pvals[k]) for k in representatives],key=lambda kv:kv[1])
+for key,pval in sorted_significant:
+    #pval = significant_pvals[key]
+    score_mat = significant_seqs[key]
+    print ">",key+"\t"+str(round(pval,5))+"\t"+str(round(np.mean(score_mat),5))
+    for j in range(opts.kmer):
+        for n in range(4):
+            print max(np.round(score_mat[j,n]*100+1),0),
+        print 
+
+        

Diff for: ensemble_utils.py

@@ -0,0 +1,69 @@
+#!/bin/env python
+import os
+import numpy as np 
+import argparse
+from ensemble_utils import *
+from CNN import *
+import argparse
+import keras
+import pickle
+from tensorflow.python.client import device_lib
+import os
+import tensorflow as tf
+from keras.backend.tensorflow_backend import set_session
+from keras import activations
+from importance_utils import *
+
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "5"
+
+config = tf.ConfigProto()
+config.gpu_options.per_process_gpu_memory_fraction = 0.4
+config.gpu_options.allow_growth = True  # dynamically grow the memory used on the GPU
+config.allow_soft_placement = True
+sess = tf.Session(config=config)
+set_session(sess)
+
+print(device_lib.list_local_devices())
+parser = argparse.ArgumentParser()
+parser.add_argument('testfasta')
+parser.add_argument('model',help="model folder")
+parser.add_argument('ioutfile')
+parser.add_argument('outfile')
+opts=parser.parse_args()
+
+X = fa_to_onehot(opts.testfasta)
+model_folders = [opts.model+"/"+d for d in os.listdir(opts.model) if os.path.isdir(opts.model+"/"+d)]
+with open(opts.model+"/model_acc.pkl","rb") as f:
+    accuracies = pickle.load(f)
+total_grads_ed = []
+total_grads_es = []
+for mi,model in enumerate(model_folders):
+    print(model)
+    grads_ed = saliency(0,model+"/model.h5",0,X,30)*X
+    grads_es = saliency(0,model+"/model.h5",1,X,30)*X
+    # grads are a X size matrix with importance scores for each
+    # sequence, for each position in the sequence
+    total_grads_ed.append(grads_ed)
+    total_grads_es.append(grads_es)
+    with open(model+"/"+opts.ioutfile+'_tp2.pkl', 'wb') as handle:
+        pickle.dump(grads_ed, handle, protocol=2)
+    with open(model+"/"+opts.ioutfile+'_tp1.pkl', 'wb') as handle:
+        pickle.dump(grads_es, handle, protocol=2)
+        
+saliency_ed = np.zeros(total_grads_ed[0].shape)
+
+for mi,model in enumerate(model_folders):    
+    saliency_ed += accuracies[model]*total_grads_ed[mi]
+saliency_ed = saliency_ed/sum(accuracies.values())
+with open(opts.outfile+'_tp1.pkl','wb') as handle:
+    pickle.dump(saliency_ed,handle,protocol=2)
+
+saliency_es = np.zeros(total_grads_es[0].shape)
+for mi,model in enumerate(model_folders):    
+    saliency_es += accuracies[model]*total_grads_es[mi]
+saliency_es = saliency_es/sum(accuracies.values())
+with open(opts.outfile+'_tp2.pkl','wb') as handle:
+    pickle.dump(saliency_es,handle,protocol=2)
+
+