import pickle
from collections import OrderedDict
import numpy as np
import pandas as pd
import os
import subprocess
import math
import copy
import pickle
import h5py
import glob

from matlas.genome_data import *
from matlas.pwms import shorten_tfname, get_motifDB_id_maps
from matlas.matches import fig2vdom, vdom_pssm
from basepair.modisco.results import ModiscoResult
from vdom.helpers import (h1, p, li, img, div, b, br, ul, a,
                          details, summary,
                          table, thead, th, tr, tbody, td, ol)
from IPython.display import display


project_root = "/mnt/lab_data/kundaje/msharmin/mouse_hem/with_tfd"
oak_root = "/oak/stanford/groups/akundaje/msharmin/mouse_hem/from_labcluster/with_tfd"
srv_root = "/srv/scratch/msharmin/mouse_hem/with_tfd"
data_name = "full_mouse50"
modisco_root = "{0}/{1}/Naive_modisco2019_msharmin".format(oak_root, data_name)
modisco_root = "{0}/{1}/Naive_modisco2019".format(srv_root, data_name)

homer_root = "{0}/{1}/Naive_scans".format(srv_root, data_name)
model_root = "{0}/{1}/fineFactorized".format(srv_root, data_name)
basset_root = "{0}/{1}/Naive_basset_motifs".format(srv_root, data_name)
reportfile= "/mnt/lab_data/kundaje/msharmin/mouse_hem/with_tfd/full_mouse50/filtering samples_MS2.xlsx"
sheetname = "filter23"

load data from labcluster

Using TensorFlow backend.
2019-10-07 09:58:06,657 [WARNING] git-lfs not installed
TF-MoDISco is using the TensorFlow backend.

from matlas.matches import DenovoModisco
task_idx = 273
modisco_dir = "{0}/task_{1}-naivegw".format(modisco_root, task_idx)
ob = DenovoModisco(modisco_dir)

task_idx = 273
modisco_dir = "{0}/task_{1}-naivegw".format(modisco_root, task_idx)
summit_file = "{0}/{1}/fineFactorized/task_{2}-naivegw/predictions/task_{2}-{3}Summit.calibrated.{1}.tab.gz".format(project_root, data_name, task_idx, "Naive")
perf_file = "{0}/task_{1}-naivegw/NaiveauPRC.txt".format(model_root, task_idx)
deeplift_hdf = "{0}/{1}/Naive_deeplift2019/task_{2}-naivegw/summit.h5".format(srv_root, data_name, task_idx)
ob = DenovoModisco(modisco_dir)
pattern_name = "metacluster_1/pattern_1"
query = ob.load_chomped_pattern(pattern_name, plot=True)

ob.initialize_with_importance_scores(summit_file, perf_file, deeplift_hdf, query.keys()) #loads all the important scores
deeplift_data = ob.deeplift_data

from matlas.utils import get_calibrated_peaks

calibrated_data = get_calibrated_peaks(summit_file, perf_file)
selected_summits = calibrated_data['selected_summits']
indices = calibrated_data['indices']

from basepair.plot.profiles import extract_signal
pattern_name = 'metacluster_1/pattern_1'
one_hot = ob.seqs_per_pattern[pattern_name]
scores = ob.contrib_per_pattern[pattern_name]
seqlets_ = ob.seqlets_per_pattern[pattern_name]
shuffled_onehot = extract_signal(ob.deeplift_data['shuffled_onehot'][indices], seqlets_)
shuffled_scores = extract_signal(ob.deeplift_data['shuffled_scores'][indices], seqlets_)

one_hot.shape, scores.shape, shuffled_onehot.shape, shuffled_scores.shape

((6372, 70, 4), (6372, 70, 4), (6372, 70, 4), (6372, 70, 4))

from matlas.matches import get_null_sequences
seq_null_onehot, seq_null_scores = get_null_sequences(one_hot, scores,
                                                shuffle_seq=True, shuffle_weight=False
                                                     )

weight_null_onehot, weight_null_scores = get_null_sequences(one_hot, scores,
                                                shuffle_seq=False, shuffle_weight=True
                                                     )

weightedseq_null_onehot, weightedseq_null_scores = get_null_sequences(one_hot, scores,
                                                shuffle_seq=True, shuffle_weight=True
                                                     )

done multiprocessing
(6372, 70, 4)
(6372, 70, 4)
done multiprocessing
(6372, 70, 4)
(6372, 70, 4)
done multiprocessing
(6372, 70, 4)
(6372, 70, 4)

from matlas.matches import collect_scoring_measures
seqlet_scores = ob.contrib_per_pattern[pattern_name]
seqlet_onehot = ob.seqs_per_pattern[pattern_name]
method_to_seqlet_scores = collect_scoring_measures(query, seqlet_scores, seqlet_onehot)
query.keys(), np.sort(np.array(list(method_to_seqlet_scores.keys())))

(dict_keys(['ppm', 'pwm', 'log10pwm', 'pssm', 'cwm', 'hyp_cwm', 'consensus']),
 array(['cwm_convolution', 'cwm_jaccard', 'cwm_masked_convolution',
        'cwm_scan', 'hyp_cwm_convolution', 'hyp_cwm_jaccard',
        'hyp_cwm_masked_convolution', 'hyp_cwm_scan',
        'log10pwm_convolution', 'log10pwm_jaccard',
        'log10pwm_masked_convolution', 'log10pwm_scan', 'ppm_convolution',
        'ppm_jaccard', 'ppm_masked_convolution', 'ppm_scan',
        'pssm_convolution', 'pssm_jaccard', 'pssm_masked_convolution',
        'pssm_scan', 'pwm_convolution', 'pwm_jaccard',
        'pwm_masked_convolution', 'pwm_scan', 'sum_score'], dtype='<U27'))

method_to_shuffled_scores = collect_scoring_measures(query, shuffled_scores, shuffled_onehot)
method_to_seq_null_scores = collect_scoring_measures(query, seq_null_scores, seq_null_onehot)
method_to_weight_null_scores = collect_scoring_measures(query, weight_null_scores, weight_null_onehot)
method_to_weightedseq_null_scores = collect_scoring_measures(query, weightedseq_null_scores, weightedseq_null_onehot)

from matlas.matches import get_any_high_scoring_instances
per_base_imp=0.0625

keys_for_scoring = ['sum_score'] 
keys_for_scoring += ["{}_scan".format(key) for key in query.keys() if key!= 'consensus']
keys_for_scoring += ["{}_jaccard".format(key) for key in query.keys() if key!= 'consensus']
keys_for_scoring += ["{}_convolution".format(key) for key in query.keys() if key!= 'consensus']
keys_for_scoring += ["{}_masked_convolution".format(key) for key in query.keys() if key!= 'consensus']
        
seqlet_hits = get_any_high_scoring_instances(method_to_seqlet_scores,
                                                min_tot_imp=per_base_imp*len(query['ppm']),
                                                keys=keys_for_scoring)

shuffled_seqlet_hits = get_any_high_scoring_instances(method_to_shuffled_scores,
                                                min_tot_imp=per_base_imp*len(query['ppm']),
                                                keys=keys_for_scoring)
seq_null_seqlet_hits = get_any_high_scoring_instances(method_to_seq_null_scores,
                                                min_tot_imp=per_base_imp*len(query['ppm']),
                                                keys=keys_for_scoring)
weight_null_seqlet_hits = get_any_high_scoring_instances(method_to_weight_null_scores,
                                                min_tot_imp=per_base_imp*len(query['ppm']),
                                                keys=keys_for_scoring)
weightedseq_null_seqlet_hits = get_any_high_scoring_instances(method_to_weightedseq_null_scores,
                                                min_tot_imp=per_base_imp*len(query['ppm']),
                                                keys=keys_for_scoring)

seqlet_hits['marker'] = 'foreground'
shuffled_seqlet_hits['marker'] = 'suffled'
seq_null_seqlet_hits['marker'] = 'seq_null'
weight_null_seqlet_hits['marker'] = 'weight_null'
weightedseq_null_seqlet_hits['marker'] = 'weightedseq'
test_hits = pd.concat([seqlet_hits,
                       shuffled_seqlet_hits,
                       seq_null_seqlet_hits,
                       weight_null_seqlet_hits,
                       weightedseq_null_seqlet_hits
                      ])

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

def transform_data(_hits, scaler=None, pca=None):
    if scaler is None:
        # should be used only during training
        scaler = StandardScaler()
        scaler.fit(_hits)
        
    # Apply transform to both the training set and testing set
    _hits = scaler.transform(_hits)

    if pca is None:
        # Make an instance of the Model
        pca = PCA(.98)
        #fitting PCA on the training set only.
        pca.fit(_hits)
        
    #Apply the mapping (transform) to both the training set and the test set.
    _hits = pca.transform(_hits)
    
    return scaler, pca, _hits

scaler, pca, train_hits = transform_data(seqlet_hits[keys_for_scoring])
pca.explained_variance_ratio_

array([0.69987347, 0.09950445, 0.08237547, 0.04125603, 0.02750585,
       0.01404074, 0.01112795, 0.00870734])

#read the real truth
def load_true_positives(tp_file):
    coordinates = []
    with open(tp_file, "r") as fp:
        for line in fp:
            line = line.strip().split(",")
            seqno = line[0]
            pos = int(line[1])
            if "-" in seqno:
                seqno = seqno.split("-")
                for i in range(int(seqno[0]), int(seqno[1])+1):
                    coordinates.append((i, pos))
            else:
                coordinates.append((int(seqno), pos))
    return coordinates

def get_tp_indices(seqlet_hits, verbose=True):
    keep = []
    for cord in coordinates:
        seqno, pos = cord
        df = seqlet_hits[(seqlet_hits['seqno']==seqno) & (seqlet_hits['start_idx']==pos)]
        if df.shape[0]>0:
            keep.append(df.index[0])
        else:
            if verbose: print(cord)

    return keep

tp_file = "{}/web_mouse_heme_data/modisco_tracks/binary_model/task_{}-naivegw/mm11_tp_spectral.txt".format(project_root, task_idx)
coordinates = load_true_positives(tp_file)
true_indices = get_tp_indices(seqlet_hits, False)

import matplotlib.pyplot as plt
def plot_pca(df, true_ids=None):
    print(df.shape)
    fig = plt.figure(figsize = (8,8))
    ax = fig.add_subplot(1,1,1) 
    ax.set_xlabel('PC1', fontsize = 15)
    ax.set_ylabel('PC2', fontsize = 15)
    ax.set_title('2 component PCA', fontsize = 20)
    if true_ids is not None:
        true_df = df.loc[np.array(true_ids),:]
        df = df.loc[np.array(list(set(list(df.index)).difference(set(true_ids)))),:]
        ax.scatter(true_df['PC1'], true_df['PC2'], s = 1, c='r', marker='+')
    ax.scatter(df['PC1'], df['PC2'], s = 1, c='b')
    #ax.axvline(9)
    #ax.axhline(-1)
    ax.grid()
    return None
pc_df = pd.DataFrame(data = train_hits, columns=["PC{}".format(i+1) for i in range(train_hits.shape[1])])
plot_pca(pc_df, true_indices)

(114461, 8)

len(true_indices)

7312

from matlas.matches import view_test_case
from modisco.visualization import viz_sequence
#from matlas.matches import view_test_cases

def view_test_cases(scores, one_hot, df, pwm, start=400, end=600, examples_to_view=None):
    
    seqnos = df.seqno.values
    positions = df.start_idx.values
    if examples_to_view is not None:
        seqnos = seqnos[examples_to_view]
        positions = positions[examples_to_view]
    
    for seqno, pos in zip(seqnos, positions):
        view_test_case(scores, one_hot, df, pwm, seqno, start=start, end=end, itemno=pos)
        
    return None
tmp_df = seqlet_hits.loc[np.sort((np.array(true_indices))),:]
# view_test_cases(seqlet_scores, 
#                seqlet_onehot, 
#                tmp_df, 
#                query['pwm'], 
#                start=0, end=70, 
#                examples_to_view=tmp_df.start_idx.values!=37)

# view_test_cases(seqlet_scores, 
#                seqlet_onehot, 
#                tmp_df, 
#                query['pwm'], 
#                start=0, end=70, 
#                examples_to_view=tmp_df.seqno.values<=1000 
#                )

# view_test_cases(seqlet_scores, 
#                seqlet_onehot, 
#                tmp_df, 
#                query['pwm'], 
#                start=0, end=70, 
#                examples_to_view=np.logical_and(tmp_df.seqno.values>1000, tmp_df.seqno.values<=2000) 
#                )

# view_test_cases(seqlet_scores, 
#                seqlet_onehot, 
#                tmp_df, 
#                query['pwm'], 
#                start=0, end=70, 
#                examples_to_view=np.logical_and(tmp_df.seqno.values>2000, tmp_df.seqno.values<=3000) 
#                )

# view_test_cases(seqlet_scores, 
#                seqlet_onehot, 
#                tmp_df, 
#                query['pwm'], 
#                start=0, end=70, 
#                examples_to_view=np.logical_and(tmp_df.seqno.values>3000, tmp_df.seqno.values<=4000) 
#                )

view_test_cases(seqlet_scores, 
               seqlet_onehot, 
               tmp_df, 
               query['pwm'], 
               start=0, end=70, 
               examples_to_view=np.logical_and(tmp_df.seqno.values>4000, tmp_df.seqno.values<=5000) 
               )

73373 ['sum_score: 4.403', 'hyp_cwm_convolution: 0.988', 'pwm_masked_convolution: 0.917', 'pwm_jaccard: 0.071', 'pwm_scan: 16.199', 'log10pwm_convolution: 5.067', 'cwm_convolution: 1.426', 'ppm_jaccard: 0.509', 'ppm_convolution: 3.747', 'cwm_jaccard: 0.694', 'hyp_cwm_scan: 1.93', 'cwm_scan: 2.657', 'pssm_convolution: 5.841', 'ppm_masked_convolution: 0.931', 'log10pwm_jaccard: 0.071', 'log10pwm_scan: 11.228', 'pssm_jaccard: 0.6', 'cwm_masked_convolution: 0.968', 'hyp_cwm_jaccard: 0.249', 'hyp_cwm_masked_convolution: 0.965', 'pssm_scan: 11.191', 'ppm_scan: 8.413', 'pssm_masked_convolution: 0.943', 'pwm_convolution: 7.31', 'log10pwm_masked_convolution: 0.917'] coordinates: (4001, 37)
37 37 48

73388 ['sum_score: 1.934', 'hyp_cwm_convolution: 0.356', 'pwm_masked_convolution: 0.83', 'pwm_jaccard: 0.05', 'pwm_scan: 10.268', 'log10pwm_convolution: 1.828', 'cwm_convolution: 0.518', 'ppm_jaccard: 0.443', 'ppm_convolution: 1.457', 'cwm_jaccard: 0.467', 'hyp_cwm_scan: 1.695', 'cwm_scan: 2.292', 'pssm_convolution: 2.188', 'ppm_masked_convolution: 0.924', 'log10pwm_jaccard: 0.05', 'log10pwm_scan: 7.117', 'pssm_jaccard: 0.441', 'cwm_masked_convolution: 0.831', 'hyp_cwm_jaccard: 0.21', 'hyp_cwm_masked_convolution: 0.856', 'pssm_scan: 9.875', 'ppm_scan: 6.804', 'pssm_masked_convolution: 0.83', 'pwm_convolution: 2.637', 'log10pwm_masked_convolution: 0.83'] coordinates: (4002, 24)
24 24 35

73394 ['sum_score: 2.547', 'hyp_cwm_convolution: 0.382', 'pwm_masked_convolution: 0.281', 'pwm_jaccard: 0.004', 'pwm_scan: -1.042', 'log10pwm_convolution: 1.337', 'cwm_convolution: 0.55', 'ppm_jaccard: 0.289', 'ppm_convolution: 1.653', 'cwm_jaccard: 0.334', 'hyp_cwm_scan: 1.144', 'cwm_scan: 1.752', 'pssm_convolution: 2.28', 'ppm_masked_convolution: 0.84', 'log10pwm_jaccard: 0.004', 'log10pwm_scan: -0.722', 'pssm_jaccard: 0.313', 'cwm_masked_convolution: 0.752', 'hyp_cwm_jaccard: 0.139', 'hyp_cwm_masked_convolution: 0.726', 'pssm_scan: 7.574', 'ppm_scan: 5.465', 'pssm_masked_convolution: 0.722', 'pwm_convolution: 1.929', 'log10pwm_masked_convolution: 0.281'] coordinates: (4002, 30)
30 30 41

73401 ['sum_score: 2.727', 'hyp_cwm_convolution: 0.532', 'pwm_masked_convolution: 0.682', 'pwm_jaccard: 0.05', 'pwm_scan: 8.915', 'log10pwm_convolution: 2.634', 'cwm_convolution: 0.834', 'ppm_jaccard: 0.411', 'ppm_convolution: 2.173', 'cwm_jaccard: 0.558', 'hyp_cwm_scan: 1.4', 'cwm_scan: 2.277', 'pssm_convolution: 3.647', 'ppm_masked_convolution: 0.908', 'log10pwm_jaccard: 0.05', 'log10pwm_scan: 6.18', 'pssm_jaccard: 0.585', 'cwm_masked_convolution: 0.912', 'hyp_cwm_jaccard: 0.175', 'hyp_cwm_masked_convolution: 0.878', 'pssm_scan: 10.132', 'ppm_scan: 7.065', 'pssm_masked_convolution: 0.931', 'pwm_convolution: 3.8', 'log10pwm_masked_convolution: 0.682'] coordinates: (4002, 37)
37 37 48

73417 ['sum_score: 4.077', 'hyp_cwm_convolution: 0.875', 'pwm_masked_convolution: 0.952', 'pwm_jaccard: 0.073', 'pwm_scan: 13.64', 'log10pwm_convolution: 4.633', 'cwm_convolution: 1.246', 'ppm_jaccard: 0.51', 'ppm_convolution: 3.429', 'cwm_jaccard: 0.639', 'hyp_cwm_scan: 1.833', 'cwm_scan: 2.515', 'pssm_convolution: 5.161', 'ppm_masked_convolution: 0.981', 'log10pwm_jaccard: 0.073', 'log10pwm_scan: 9.455', 'pssm_jaccard: 0.593', 'cwm_masked_convolution: 0.951', 'hyp_cwm_jaccard: 0.228', 'hyp_cwm_masked_convolution: 0.963', 'pssm_scan: 10.73', 'ppm_scan: 7.817', 'pssm_masked_convolution: 0.934', 'pwm_convolution: 6.684', 'log10pwm_masked_convolution: 0.952'] coordinates: (4003, 37)
37 37 48

73434 ['sum_score: 2.793', 'hyp_cwm_convolution: 0.755', 'pwm_masked_convolution: 0.824', 'pwm_jaccard: 0.059', 'pwm_scan: 11.417', 'log10pwm_convolution: 3.584', 'cwm_convolution: 1.13', 'ppm_jaccard: 0.335', 'ppm_convolution: 2.594', 'cwm_jaccard: 0.56', 'hyp_cwm_scan: 1.718', 'cwm_scan: 2.335', 'pssm_convolution: 4.594', 'ppm_masked_convolution: 0.847', 'log10pwm_jaccard: 0.059', 'log10pwm_scan: 7.913', 'pssm_jaccard: 0.472', 'cwm_masked_convolution: 0.963', 'hyp_cwm_jaccard: 0.198', 'hyp_cwm_masked_convolution: 0.936', 'pssm_scan: 10.225', 'ppm_scan: 7.218', 'pssm_masked_convolution: 0.921', 'pwm_convolution: 5.171', 'log10pwm_masked_convolution: 0.824'] coordinates: (4004, 37)
37 37 48

73474 ['sum_score: 4.044', 'hyp_cwm_convolution: 0.89', 'pwm_masked_convolution: 0.888', 'pwm_jaccard: 0.082', 'pwm_scan: 12.875', 'log10pwm_convolution: 4.788', 'cwm_convolution: 1.261', 'ppm_jaccard: 0.497', 'ppm_convolution: 3.413', 'cwm_jaccard: 0.598', 'hyp_cwm_scan: 1.563', 'cwm_scan: 2.448', 'pssm_convolution: 5.292', 'ppm_masked_convolution: 0.929', 'log10pwm_jaccard: 0.082', 'log10pwm_scan: 8.924', 'pssm_jaccard: 0.551', 'cwm_masked_convolution: 0.924', 'hyp_cwm_jaccard: 0.23', 'hyp_cwm_masked_convolution: 0.961', 'pssm_scan: 10.728', 'ppm_scan: 7.758', 'pssm_masked_convolution: 0.909', 'pwm_convolution: 6.908', 'log10pwm_masked_convolution: 0.888'] coordinates: (4005, 37)
37 37 48

73495 ['sum_score: 4.052', 'hyp_cwm_convolution: 0.859', 'pwm_masked_convolution: 0.945', 'pwm_jaccard: 0.08', 'pwm_scan: 16.199', 'log10pwm_convolution: 4.542', 'cwm_convolution: 1.207', 'ppm_jaccard: 0.546', 'ppm_convolution: 3.354', 'cwm_jaccard: 0.68', 'hyp_cwm_scan: 1.93', 'cwm_scan: 2.657', 'pssm_convolution: 4.924', 'ppm_masked_convolution: 0.958', 'log10pwm_jaccard: 0.08', 'log10pwm_scan: 11.228', 'pssm_jaccard: 0.565', 'cwm_masked_convolution: 0.942', 'hyp_cwm_jaccard: 0.247', 'hyp_cwm_masked_convolution: 0.964', 'pssm_scan: 11.191', 'ppm_scan: 8.413', 'pssm_masked_convolution: 0.914', 'pwm_convolution: 6.553', 'log10pwm_masked_convolution: 0.945'] coordinates: (4006, 37)
37 37 48

73515 ['sum_score: 3.716', 'hyp_cwm_convolution: 0.912', 'pwm_masked_convolution: 0.884', 'pwm_jaccard: 0.063', 'pwm_scan: 12.708', 'log10pwm_convolution: 4.298', 'cwm_convolution: 1.275', 'ppm_jaccard: 0.388', 'ppm_convolution: 3.182', 'cwm_jaccard: 0.574', 'hyp_cwm_scan: 1.76', 'cwm_scan: 2.45', 'pssm_convolution: 5.196', 'ppm_masked_convolution: 0.903', 'log10pwm_jaccard: 0.063', 'log10pwm_scan: 8.809', 'pssm_jaccard: 0.508', 'cwm_masked_convolution: 0.943', 'hyp_cwm_jaccard: 0.236', 'hyp_cwm_masked_convolution: 0.971', 'pssm_scan: 10.595', 'ppm_scan: 7.465', 'pssm_masked_convolution: 0.91', 'pwm_convolution: 6.201', 'log10pwm_masked_convolution: 0.884'] coordinates: (4007, 37)
37 37 48

73531 ['sum_score: 4.195', 'hyp_cwm_convolution: 0.87', 'pwm_masked_convolution: 0.673', 'pwm_jaccard: 0.043', 'pwm_scan: 9.926', 'log10pwm_convolution: 3.267', 'cwm_convolution: 1.192', 'ppm_jaccard: 0.349', 'ppm_convolution: 2.95', 'cwm_jaccard: 0.477', 'hyp_cwm_scan: 1.722', 'cwm_scan: 2.266', 'pssm_convolution: 4.959', 'ppm_masked_convolution: 0.862', 'log10pwm_jaccard: 0.043', 'log10pwm_scan: 6.88', 'pssm_jaccard: 0.432', 'cwm_masked_convolution: 0.882', 'hyp_cwm_jaccard: 0.215', 'hyp_cwm_masked_convolution: 0.933', 'pssm_scan: 9.922', 'ppm_scan: 6.786', 'pssm_masked_convolution: 0.865', 'pwm_convolution: 4.714', 'log10pwm_masked_convolution: 0.673'] coordinates: (4008, 37)
37 37 48

# view_test_cases(seqlet_scores, 
#                seqlet_onehot, 
#                tmp_df, 
#                query['pwm'], 
#                start=0, end=70, 
#                examples_to_view=np.logical_and(tmp_df.seqno.values>5000, tmp_df.seqno.values<=6000) 
#                )

# view_test_cases(seqlet_scores, 
#                seqlet_onehot, 
#                tmp_df, 
#                query['pwm'], 
#                start=0, end=70, 
#                examples_to_view=tmp_df.seq.values>6000 
#                )

from sklearn.mixture import GaussianMixture
#import sklearn.mixture.GaussianMixture
gmm = GaussianMixture(n_components=2).fit(pc_df[['PC1', 'PC2']])
labels = gmm.predict(pc_df[['PC1', 'PC2']])
plt.scatter(pc_df['PC1'], pc_df['PC2'], c=labels, s=1, cmap='viridis');

probs = gmm.predict_proba(pc_df[['PC1', 'PC2']])
plt.scatter(pc_df['PC1'], pc_df['PC2'], c=probs[:,1], s=1, cmap='seismic');

_, _, test_hits = transform_data(shuffled_seqlet_hits[keys_for_scoring], scaler, pca)
shuffled_pc_df = pd.DataFrame(data = test_hits, columns=["PC{}".format(i+1) for i in range(test_hits.shape[1])])
#plot_pca(shuffled_pc_df, true_ids=None)

probs = gmm.predict_proba(shuffled_pc_df[['PC1', 'PC2']])
plt.scatter(shuffled_pc_df['PC1'], shuffled_pc_df['PC2'], c=probs[:,1], s=1, cmap='seismic');

_, _, test_hits = transform_data(seq_null_seqlet_hits[keys_for_scoring], scaler, pca)
seq_null_pc_df = pd.DataFrame(data = test_hits, columns=["PC{}".format(i+1) for i in range(test_hits.shape[1])])
#plot_pca(shuffled_pc_df, true_ids=None)

probs = gmm.predict_proba(seq_null_pc_df[['PC1', 'PC2']])
plt.scatter(seq_null_pc_df['PC1'], seq_null_pc_df['PC2'], c=probs[:,1], s=1, cmap='seismic');

_, _, test_hits = transform_data(weight_null_seqlet_hits[keys_for_scoring], scaler, pca)
weight_null_pc_df = pd.DataFrame(data = test_hits, columns=["PC{}".format(i+1) for i in range(test_hits.shape[1])])
#plot_pca(weight_null_pc_df, true_ids=None)

probs = gmm.predict_proba(weight_null_pc_df[['PC1', 'PC2']])
plt.scatter(weight_null_pc_df['PC1'], weight_null_pc_df['PC2'], c=probs[:,1], s=1, cmap='seismic');

_, _, test_hits = transform_data(weightedseq_null_seqlet_hits[keys_for_scoring], scaler, pca)
weightedseq_null_pc_df = pd.DataFrame(data = test_hits, columns=["PC{}".format(i+1) for i in range(test_hits.shape[1])])
#plot_pca(weightedseq_null_pc_df, true_ids=None)

probs = gmm.predict_proba(weightedseq_null_pc_df[['PC1', 'PC2']])
plt.scatter(weightedseq_null_pc_df['PC1'], weightedseq_null_pc_df['PC2'], c=probs[:,1], s=1, cmap='seismic');

pca_seqlet_hits = pc_df[['PC1', 'PC2', 'PC3']]
pca_shuffled_seqlet_hits = shuffled_pc_df[['PC1', 'PC2', 'PC3']]
pca_seq_null_seqlet_hits = seq_null_pc_df[['PC1', 'PC2', 'PC3']]
pca_weight_null_seqlet_hits = weight_null_pc_df[['PC1', 'PC2', 'PC3']]
pca_weightedseq_null_seqlet_hits = weightedseq_null_pc_df[['PC1', 'PC2', 'PC3']]
pca_seqlet_hits['marker'] = 'foreground'
pca_shuffled_seqlet_hits['marker'] = 'suffled'
pca_seq_null_seqlet_hits['marker'] = 'seq_null'
pca_weight_null_seqlet_hits['marker'] = 'weight_null'
pca_weightedseq_null_seqlet_hits['marker'] = 'weightedseq'
pca_test_hits = pd.concat([pca_seqlet_hits,
                       pca_shuffled_seqlet_hits,
                       pca_seq_null_seqlet_hits,
                       pca_weight_null_seqlet_hits,
                       pca_weightedseq_null_seqlet_hits
                      ])

# import seaborn as sns
# sns.pairplot(pca_test_hits, 
#              diag_kind="kde", kind='scatter', hue="marker")

/users/msharmin/anaconda2/envs/basepair/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning:

Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.

<seaborn.axisgrid.PairGrid at 0x7f0669a8beb8>

# sns.pairplot(pd.concat([pca_seqlet_hits, pca_shuffled_seqlet_hits]), 
#              diag_kind="kde", kind='scatter', hue="marker")

/users/msharmin/anaconda2/envs/basepair/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning:

Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.

<seaborn.axisgrid.PairGrid at 0x7f0683430780>

# sns.pairplot(pd.concat([pca_seqlet_hits, pca_seq_null_seqlet_hits]), 
#              diag_kind="kde", kind='scatter', hue="marker")

/users/msharmin/anaconda2/envs/basepair/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning:

Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.

<seaborn.axisgrid.PairGrid at 0x7f013adc8278>

# sns.pairplot(pd.concat([pca_seqlet_hits, pca_weight_null_seqlet_hits]), 
#              diag_kind="kde", kind='scatter', hue="marker")

/users/msharmin/anaconda2/envs/basepair/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning:

Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.

<seaborn.axisgrid.PairGrid at 0x7f06833e0978>

# sns.pairplot(pd.concat([pca_seqlet_hits, pca_weightedseq_null_seqlet_hits]), 
#              diag_kind="kde", kind='scatter', hue="marker")

/users/msharmin/anaconda2/envs/basepair/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning:

Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.

<seaborn.axisgrid.PairGrid at 0x7f0680a80cf8>

from sklearn.cluster import SpectralClustering
from sklearn.svm import LinearSVC, SVC
from sklearn.cluster import AffinityPropagation
def get_spectral_high_scoring_instances(train_df, keys_to_cluster, test_df=None, clustering=None, cno=None):
    train = train_df[keys_to_cluster]
    
    if clustering is None:
        clustering = SpectralClustering(n_clusters=2, assign_labels="discretize", random_state=0).fit(train.values)
        mean0 = np.mean(train_df[keys_to_cluster[0]][clustering.labels_==0])
        mean1 = np.mean(train_df[keys_to_cluster[0]][clustering.labels_==1])
        cno = 1
        if(mean0 > mean1):
            cno = 0
        df = train_df[clustering.labels_==cno]
    else:
        test = test_df[keys_to_cluster]
        y_tr = clustering.labels_
        #clf = LinearSVC(dual=False).fit(train.values, y_tr)
        clf = SVC().fit(train.values, y_tr)
        batch_size = 1000
        batch_count = int(np.ceil(1.0*test_df.shape[0]/batch_size))
        predicted_labels = clf.predict(test.values)
        predicted_labels = np.array(predicted_labels)
        assert len(predicted_labels)==test_df.shape[0], "not all the values have been predicted"
        df = test_df.loc[predicted_labels==cno, :]
        
    #df = df[df['pwm_jaccard']>0]
    
    return df, (clustering, cno)

# import sys
# from matlas.matches import clustering_method_to_functions#, get_spectral_high_scoring_instances
# from random import sample

# max_instances_to_cluster = min(seqlet_hits.shape[0], 20000) #similar size as the gata motif
# pca_seqlet_hits = pc_df[['PC1', 'PC2']]
# train_hits_forcluster = pca_seqlet_hits.loc[sample(list(seqlet_hits.index), max_instances_to_cluster),:]
# #train_hits_forcluster = pc_df[['PC1', 'PC2']]

# clustering_method = 'spectral'
# thismodule = sys.modules[__name__]
# method_to_call = getattr(thismodule, clustering_method_to_functions[clustering_method])

# #use a subset of the hits to build the cluster
# clustered_seqlet_hits, (clustering, cno) = method_to_call(train_hits_forcluster,
#                                                           keys_to_cluster=['PC1', 'PC2']
#                                                          )

# #use the cluster to predict on the full set of seqlets
# clustered_seqlet_hits2, (_, _) = method_to_call(train_hits_forcluster, #train_df
#                                         ['PC1', 'PC2'], #keys_to_cluster
#                                         pca_seqlet_hits, #test_df
#                                         clustering, #clustering
#                                         cno)

# clustered_seqlet_hits.shape, clustered_seqlet_hits2.shape, clustered_seqlet_hits3.shape

((1275, 2), (7307, 4), (605, 4))

# clustered_seqlet_hits3, (_, _) = method_to_call(train_hits_forcluster, #train_df
#                                         ['PC1', 'PC2'], #keys_to_cluster
#                                         pca_shuffled_seqlet_hits, #test_df
#                                         clustering, #clustering
#                                         cno)

# tp_file = "{}/web_mouse_heme_data/modisco_tracks/binary_model/task_{}-naivegw/mm11_tp_random.txt".format(project_root, task_idx)
# write_tp(shuffled_seqlet_hits.loc[clustered_seqlet_hits3.index,:], tp_file)
# coordinates = load_true_positives(tp_file)
# true_indices = get_tp_indices(shuffled_seqlet_hits, verbose=False)
# plot_pca(shuffled_pc_df, true_indices)

(48842, 8)

# clustered_seqlet_hits3, (_, _) = method_to_call(train_hits_forcluster, #train_df
#                                         ['PC1', 'PC2'], #keys_to_cluster
#                                         pca_seq_null_seqlet_hits, #test_df
#                                         clustering, #clustering
#                                         cno)

# tp_file = "{}/web_mouse_heme_data/modisco_tracks/binary_model/task_{}-naivegw/mm11_tp_random.txt".format(project_root, task_idx)
# write_tp(seqlet_hits.loc[clustered_seqlet_hits3.index,:], tp_file)
# coordinates = load_true_positives(tp_file)
# true_indices = get_tp_indices(seq_null_seqlet_hits, verbose=False)
# plot_pca(seq_null_pc_df, true_indices)

(114461, 8)

# clustered_seqlet_hits3, (_, _) = method_to_call(train_hits_forcluster, #train_df
#                                         ['PC1', 'PC2'], #keys_to_cluster
#                                         pca_weight_null_seqlet_hits, #test_df
#                                         clustering, #clustering
#                                         cno)

# tp_file = "{}/web_mouse_heme_data/modisco_tracks/binary_model/task_{}-naivegw/mm11_tp_random.txt".format(project_root, task_idx)
# write_tp(weight_null_seqlet_hits.loc[clustered_seqlet_hits3.index,:], tp_file)
# coordinates = load_true_positives(tp_file)
# true_indices = get_tp_indices(weight_null_seqlet_hits, verbose=False)
# plot_pca(weight_null_pc_df, true_indices)

(124266, 8)

# clustered_seqlet_hits3, (_, _) = method_to_call(train_hits_forcluster, #train_df
#                                         ['PC1', 'PC2'], #keys_to_cluster
#                                         pca_weightedseq_null_seqlet_hits, #test_df
#                                         clustering, #clustering
#                                         cno)

# tp_file = "{}/web_mouse_heme_data/modisco_tracks/binary_model/task_{}-naivegw/mm11_tp_random.txt".format(project_root, task_idx)
# write_tp(weightedseq_null_seqlet_hits.loc[clustered_seqlet_hits3.index,:], tp_file)
# coordinates = load_true_positives(tp_file)
# true_indices = get_tp_indices(weightedseq_null_seqlet_hits, verbose=False)
# plot_pca(weightedseq_null_pc_df, true_indices)

(123596, 8)