In [1]:

    

import glob

import numpy as np
import pandas as pd

from grafting_classifier import GraftingClassifier
from sklearn.linear_model import SGDClassifier
from ogfs_classifier import OGFSClassifier
from osfs_classifier import OSFSClassifier
from dpp_classifier import DPPClassifier
from dpp_classifier_mitra import DPPClassifier as DPPClassifier2
from dpp_classifier_ogfs import DPPClassifier as DPPClassifier3

from sklearn.metrics import log_loss, accuracy_score

#import dask.dataframe as dd
#import dask.array as da


    

In [2]:

    

class_train = glob.glob("microarray/*_train.csv")
print(class_train)


    

    




['microarray\\colon_train.csv', 'microarray\\leukemia_train.csv', 'microarray\\lung_cancer_train.csv', 'microarray\\prostate_train.csv']

In [3]:

    

def train_label(fname):
    targetname = fname.replace(".csv", ".labels")
    return pd.read_csv(targetname)


    

In [4]:

    

def get_performance(mod, fpath, base=False):
    train1 = pd.read_csv(fpath).fillna(0)
    y = np.array(train_label(fpath)).flatten()
    
    # simulate streaming...
    # try splitting into groups of ~10,
    # if there is no splits, try ~5.
    train1_cols = np.array_split(range(train1.shape[1]), int(train1.shape[1]/10.0) + 1)
    if len(train1_cols) == 1:
        train1_cols = np.array_split(range(train1.shape[1]), int(train1.shape[1]/5.0) + 1)
    all_cols = []

    #mod = GraftingClassifier(max_iter=5)
    if base:
        mod.fit(train1, y)
        results = {'accuracy': accuracy_score(y, mod.predict(train1)), 
               'logloss': log_loss(y, mod.predict_proba(train1)), 
               'feat_dim': mod.coef_.flatten().shape}
        return results

    # lets normalise the dataset...
    train1 = (train1 - train1.mean())/(np.maximum(train1.std(), 1))
    for idx, collist in enumerate(train1_cols):
        if idx == 0:
            column_list = list(np.array(list(train1.columns))[collist])
            mod.fit(train1[column_list], y)
            all_cols.extend(list(collist))
        else:
            all_cols.extend(list(collist))
            column_list = list(np.array(list(train1.columns))[all_cols])
            mod.partial_fit(train1[column_list], y)
    
    results = {'accuracy': accuracy_score(y, mod.predict(train1)), 
               'logloss': log_loss(y, mod.predict_proba(train1)), 
               'feat_dim': mod.coef_.flatten().shape}
    return results


    

In [5]:

    

def create_models():
    return [
    ('Grafting', GraftingClassifier(max_iter=5, random_state=42)), 
    #('DPP', DPPClassifier(max_iter=5, random_state=42)), 
    #('DPP2', DPPClassifier2(max_iter=5, random_state=42)),
    #('DPP3', DPPClassifier3(max_iter=5, random_state=42)),
    #('OGFS', OGFSClassifier(max_iter=5, random_state=42)),
    ('OSFS', OSFSClassifier(max_iter=5, random_state=42)),
    ('Base', SGDClassifier(loss='log', max_iter=5, random_state=42))
]


    

In [6]:

    

ex_dat = class_train[0]
test = pd.read_csv(ex_dat)


    

In [7]:

    

test.shape


    

    
Out[7]:





(62, 2000)

In [8]:

    

ex_dat = class_train[0]
models = create_models()
for nm, mod in models:
    if nm != 'Base':
        print(nm, get_performance(mod, ex_dat))
    else:
        print(nm, get_performance(mod, ex_dat, base=True))


    

    




Grafting {'accuracy': 1.0, 'logloss': 0.0014270972910958913, 'feat_dim': (161,)}
OSFS {'accuracy': 0.74193548387096775, 'logloss': 5.6665966354354493, 'feat_dim': (155,)}
Base {'accuracy': 0.66129032258064513, 'logloss': 11.698617811179425, 'feat_dim': (2000,)}






    




C:\Users\chapm\Anaconda3\envs\skrecipe\lib\site-packages\sklearn\linear_model\base.py:340: RuntimeWarning: overflow encountered in exp
  np.exp(prob, prob)

In [9]:

    

ex_dat = class_train[1]
print(ex_dat, pd.read_csv(ex_dat).shape)
models = create_models()
for nm, mod in models:
    if nm != 'Base':
        print(nm, get_performance(mod, ex_dat))
    else:
        print(nm, get_performance(mod, ex_dat, base=True))


    

    




microarray\leukemia_train.csv (72, 7129)
Grafting {'accuracy': 1.0, 'logloss': 0.0011366162524629752, 'feat_dim': (112,)}
OSFS {'accuracy': 0.91666666666666663, 'logloss': 0.13074169321461199, 'feat_dim': (14,)}
Base {'accuracy': 1.0, 'logloss': 9.9920072216264148e-16, 'feat_dim': (7129,)}






    




C:\Users\chapm\Anaconda3\envs\skrecipe\lib\site-packages\sklearn\linear_model\base.py:340: RuntimeWarning: overflow encountered in exp
  np.exp(prob, prob)

In [10]:

    

ex_dat = class_train[2]
print(ex_dat, pd.read_csv(ex_dat).shape)
models = create_models()
for nm, mod in models:
    if nm != 'Base':
        print(nm, get_performance(mod, ex_dat))
    else:
        print(nm, get_performance(mod, ex_dat, base=True))


    

    




microarray\lung_cancer_train.csv (181, 12533)
Grafting {'accuracy': 1.0, 'logloss': 0.00058025328079361208, 'feat_dim': (79,)}
OSFS {'accuracy': 1.0, 'logloss': 0.018680295944004336, 'feat_dim': (15,)}
Base {'accuracy': 1.0, 'logloss': 9.9920072216264128e-16, 'feat_dim': (12533,)}






    




C:\Users\chapm\Anaconda3\envs\skrecipe\lib\site-packages\sklearn\linear_model\base.py:340: RuntimeWarning: overflow encountered in exp
  np.exp(prob, prob)

In [11]:

    

ex_dat = class_train[3]
print(ex_dat, pd.read_csv(ex_dat).shape)
models = create_models()
for nm, mod in models:
    if nm != 'Base':
        print(nm, get_performance(mod, ex_dat))
    else:
        print(nm, get_performance(mod, ex_dat, base=True))


    

    




microarray\prostate_train.csv (102, 12600)
Grafting {'accuracy': 1.0, 'logloss': 0.0015230494955966651, 'feat_dim': (153,)}
OSFS {'accuracy': 1.0, 'logloss': 0.037702761542082443, 'feat_dim': (34,)}
Base {'accuracy': 0.91176470588235292, 'logloss': 3.0475390936685902, 'feat_dim': (12600,)}






    




C:\Users\chapm\Anaconda3\envs\skrecipe\lib\site-packages\sklearn\linear_model\base.py:340: RuntimeWarning: overflow encountered in exp
  np.exp(prob, prob)