skchem.target_prediction.PIDGIN

Complexity

Total Complexity

27

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

14 Methods

Rating	Name	Duplication	Size	Complexity
A	PIDGIN.__init__()	0	9	2
A	PIDGIN._m_predict()	0	7	2
A	PIDGIN._map_predict_proba()	0	7	2
A	PIDGIN._df_map_predict_proba()	0	9	2
A	PIDGIN.map_predict_log_proba()	0	8	2
A	PIDGIN._df_predict_log_proba()	10	10	2
A	PIDGIN._map_predict()	0	7	2
A	PIDGIN._df_predict()	0	9	2
A	PIDGIN._df_map_predict_log_proba()	0	11	2
A	PIDGIN._df_map_predict()	0	9	2
A	PIDGIN._m_predict_log_proba()	0	9	2
A	PIDGIN.__call__()	0	2	1
A	PIDGIN._m_predict_proba()	0	9	2
A	PIDGIN._df_predict_proba()	11	11	2

#! /usr/bin/env python
#
# Copyright (C) 2007-2009 Rich Lewis <rl403@cam.ac.uk>
# License: 3-clause BSD

# The map functions are a stand in before parallelism is applied,
# so ignore the errors for using map + lambdas.

# pylint: disable=W0110

Locally disabling deprecated-lambda (W0110)

"""
skchem.target_prediction.PIDGIN

Wrapper for the PIDGIN models.
"""

import pandas as pd

The import pandas could not be resolved.

from rdkit.Chem.rdMolDescriptors import GetMorganFingerprintAsBitVect

The import rdkit.Chem.rdMolDescriptors could not be resolved.

import gzip

import sys

# if cpickle available, import it.  otherwise use pickle
try:
    import cPickle as pickle
except ImportError:
    import pickle

from .target_prediction import AbstractTargetPredictionAlgorithm
from ..descriptors import skchemize
from ..data import resource

class PIDGIN(AbstractTargetPredictionAlgorithm):

    """ Class implementing the PIDGIN target prediction algorithm """

    def __init__(self):
        # fix py3 incompat by creating py2k and py3k PIDGIN models
        filename = 'models_{}{}.pkl.gz'.format(*sys.version_info[:2])

        with gzip.open(resource('PIDGIN', filename), 'rb') as f:

The name f does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

            self.models = pickle.load(f)
        self.fingerprint = skchemize(GetMorganFingerprintAsBitVect, \
                                        radius=2, nBits=2048)
        self.targets = self.models.keys()

    def __call__(self, m):
        return self.predict_proba(m)

    def _m_predict(self, m):

        """ Predict binary binding profile for a molecule against 1080 protein targets """

        fp = self.fingerprint(m)

The name fp does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

        return pd.Series((self.models[targ].predict(fp)[0] for targ in self.targets), \
                            index=self.targets)

    def _map_predict(self, m):

The name m does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

        """ Map based prediction for binary binding profile """

        fp = self.fingerprint(m)

The name fp does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

        return pd.Series(map(lambda k: self.models[k].predict(fp), self.targets), \

Used builtin function 'map'

                                                index=self.targets)

    def _m_predict_proba(self, m):

        """ Predict probability of molecule m binding to 1080 protein targets """

        fp = self.fingerprint(m)

The name fp does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

        res = pd.Series(index=self.targets)
        for target in self.models:
            res[target] = self.models[target].predict_proba(fp)[:, 1][0]
        return res

    def _map_predict_proba(self, m):

The name m does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

        """ Predict the log probability of molecule m binding to the 1080 proteins """

        fp = self.fingerprint(m)

The name fp does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

        return pd.Series(map(lambda k: self.models[k].predict_proba(fp)[:, 1][0],\

Used builtin function 'map'

                                                self.targets), index=self.targets)

    def _m_predict_log_proba(self, m):

        """ Predict the log probability of molecule m binding to the 1080 proteins """

        fp = self.fingerprint(m)

The name fp does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

        res = pd.Series(index=self.targets)
        for target, model in self.models.iteritems():
            res[target] = model.predict_log_proba(fp)[:, 1][0]
        return res

    def map_predict_log_proba(self, m):

The name m does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

        """ Predict the log probabiltiy of molecule m binding to the 1080 proteins
        using map, for simple parallelism """

        fp = self.fingerprint(m)

The name fp does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

        return pd.Series(map(lambda k: self.models[k].predict_log_proba(fp[:, 1][0]), \

Used builtin function 'map'

                                                self.targets), index=self.targets)

    def _df_predict(self, df):

        """more efficient way to call the predict on large scikit-chem style dataframes"""

        fps = df.structure.apply(self.fingerprint)
        res = pd.DataFrame(index=fps.index, columns=self.targets)
        for target in self.models:
            res[target] = self.models[target].predict(fps)
        return res

    def _df_map_predict(self, df):

The name df does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

        """ More efficient way to call the predict on large scikit-chem style dataframes,
        with a map implementation for easy parallelism"""

        fps = df.structure.apply(self.fingerprint)

        return pd.DataFrame(map(lambda k: self.models[k].predict(fps), self.targets), \

Used builtin function 'map'

                                        columns=fps.index, index=self.targets).T


    def _df_predict_proba(self, df):

This code seems to be duplicated in your project.

        """ More efficient way to call the predict_proba on large scikit-chem style dataframes"""

        fps = df.structure.apply(self.fingerprint)
        res = pd.DataFrame(index=fps.index, columns=self.targets)

        #parallelize here
        for target in self.models:
            res[target] = self.models[target].predict_proba(fps)[:, 1]
        return res

    def _df_map_predict_proba(self, df):

The name df does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

        """ map based way to call the predict_proba on large scikit-chem style dataframes """

        fps = df.structure.apply(self.fingerprint)

        #parallize here trivially
        return pd.DataFrame(map(lambda k: self.models[k].predict_proba(fps)[:, 1], self.targets), \

Used builtin function 'map'

                                            columns=fps.index, index=self.targets).T

    def _df_predict_log_proba(self, df):

This code seems to be duplicated in your project.

        """ More efficient way to call the predict_proba on large scikit-chem style dataframes"""

        fps = df.structure.apply(self.fingerprint)
        res = pd.DataFrame(index=fps.index, columns=self.targets)

        for target in self.models:
            res[target] = self.models[target].predict_log_proba(fps)[:, 1]
        return res

    def _df_map_predict_log_proba(self, df):

The name df does not conform to the argument naming conventions ([a-z_][a-z0-9_]{2,30}$).

        """
        More efficient way to call the predict on large scikit-chem style dataframes,
        with a map implementation for easy parallelism
        """

        fps = df.structure.apply(self.fingerprint)

        return pd.DataFrame(map(lambda k: self.models[k].predict_log_proba(fps)[:, 1], \

Used builtin function 'map'

                                        self.targets), columns=fps.index, index=self.targets).T