scikit-multilearn-0.0.3/0000775000175000017500000000000012724336162016212 5ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/PKG-INFO0000664000175000017500000000166412724336162017316 0ustar niedakhniedakh00000000000000Metadata-Version: 1.1 Name: scikit-multilearn Version: 0.0.3 Summary: A set of python modules for multi-label classification Home-page: http://scikit-multilearn.github.io/ Author: Piotr Szymański Author-email: niedakh@gmail.com License: BSD Description: UNKNOWN Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Environment :: Console Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Education Classifier: Intended Audience :: Science/Research Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: Microsoft :: Windows Classifier: Operating System :: POSIX Classifier: Programming Language :: Python Classifier: Topic :: Scientific/Engineering Classifier: Topic :: Scientific/Engineering :: Information Analysis Classifier: Topic :: Scientific/Engineering :: Bio-Informatics scikit-multilearn-0.0.3/skmultilearn/0000775000175000017500000000000012724336162020724 5ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/skmultilearn/dataset.py0000664000175000017500000001663612724335503022735 0ustar niedakhniedakh00000000000000import arff import bz2 import pickle import numpy as np from scipy import sparse class Dataset(object): @classmethod def load_arff_to_numpy(cls, filename, labelcount, endian="big", input_feature_type='float', encode_nominal=True, load_sparse=False): """Method for loading ARFF files as numpy array Parameters ---------- filename : string Path to ARFF file labelcount: integer Number of labels in the ARFF file endian: string{"big", "little"} Whether the ARFF file contains labels at the beginning of the attributes list ("big" endianness, MEKA format) or at the end ("little" endianness, MULAN format) input_feature_type: numpy.type as string The desire type of the contents of the return 'X' array-likes, default 'i8', should be a numpy type, see http://docs.scipy.org/doc/numpy/user/basics.types.html encode_nominal: boolean Whether convert categorical data into numeric factors - required for some scikit classifiers that can't handle non-numeric input featuers. load_sparse: boolean Whether to read arff file as a sparse file format, liac-arff breaks if sparse reading is enabled for non-sparse ARFFs. Returns ------- data: dictionary {'X': scipy sparse matrix with input_feature_type elements, 'y': scipy sparse matrix of binary (int8) label vectors } The dictionary containing the data frame, with 'X' key storing the input space array-like of input feature vectors and 'y' storing labels assigned to each input vector, as a binary indicator vector (i.e. if 5th position has value 1 then the input vector has label no. 5) """ matrix = None if not load_sparse: arff_frame = arff.load( open(filename, 'rb'), encode_nominal=encode_nominal, return_type=arff.DENSE) matrix = sparse.csr_matrix( arff_frame['data'], dtype=input_feature_type) else: arff_frame = arff.load( open(filename, 'rb'), encode_nominal=encode_nominal, return_type=arff.COO) data = arff_frame['data'][0] row = arff_frame['data'][1] col = arff_frame['data'][2] matrix = sparse.coo_matrix( (data, (row, col)), shape=(max(row) + 1, max(col) + 1)) X, y = None, None if endian == "big": X, y = matrix.tocsc()[:, labelcount:].tolil(), matrix.tocsc()[ :, :labelcount].astype(int).tolil() elif endian == "little": X, y = matrix.tocsc()[ :, :-labelcount].tolil(), matrix.tocsc()[:, -labelcount:].astype(int).tolil() else: # unknown endian return None return X, y @classmethod def save_to_arff(cls, X, y, endian="little", save_sparse=True): """Method for loading ARFF files as numpy array Parameters ---------- filename : string Path to ARFF file labelcount: integer Number of labels in the ARFF file endian: string{"big", "little"} Whether the ARFF file contains labels at the beginning of the attributes list ("big" endianness, MEKA format) or at the end ("little" endianness, MULAN format) input_feature_type: numpy.type as string The desire type of the contents of the return 'X' array-likes, default 'i8', should be a numpy type, see http://docs.scipy.org/doc/numpy/user/basics.types.html encode_nominal: boolean Whether convert categorical data into numeric factors - required for some scikit classifiers that can't handle non-numeric input featuers. save_sparse: boolean Whether to read arff file as a sparse file format, liac-arff breaks if sparse reading is enabled for non-sparse ARFFs. Returns ------- data: dictionary {'X': scipy sparse matrix with input_feature_type elements, 'y': scipy sparse matrix of binary (int8) label vectors } The dictionary containing the data frame, with 'X' key storing the input space array-like of input feature vectors and 'y' storing labels assigned to each input vector, as a binary indicator vector (i.e. if 5th position has value 1 then the input vector has label no. 5) """ X = X.todok() y = y.todok() x_prefix = 0 y_prefix = 0 x_attributes = [(u'X{}'.format(i), u'NUMERIC') for i in xrange(X.shape[1])] y_attributes = [(u'y{}'.format(i), [unicode(0), unicode(1)]) for i in xrange(y.shape[1])] if endian == "big": y_prefix = X.shape[1] relation_sign = -1 attributes = x_attributes + y_attributes elif endian == "little": x_prefix = y.shape[1] relation_sign = 1 attributes = y_attributes + x_attributes else: raise ValueError("Endian not in {big, little}") if save_sparse: data = [{} for r in xrange(X.shape[0])] else: data = [[0 for c in xrange(X.shape[1] + y.shape[1])] for r in xrange(X.shape[0])] for keys, value in X.iteritems(): data[keys[0]][x_prefix + keys[1]] = value for keys, value in y.iteritems(): data[keys[0]][y_prefix + keys[1]] = value dataset = { u'description': u'traindata', u'relation': u'traindata: -C {}'.format(y.shape[1] * relation_sign), u'attributes': attributes, u'data': data } return arff.dumps(dataset) @classmethod def save_dataset_dump(cls, filename, input_space, labels): """Saves a compressed data set dump Parameters ---------- filename : string Path to dump file, if without .bz2, the .bz2 extension will be appended. input_space: array-like of array-likes Input space array-like of input feature vectors labels: array-like of binary label vectors Array-like of labels assigned to each input vector, as a binary indicator vector (i.e. if 5th position has value 1 then the input vector has label no. 5) """ if filename[-4:] != '.bz2': filename += ".bz2" with bz2.BZ2File(filename, "wb") as file_handle: pickle.dump({'X': input_space, 'y': labels}, file_handle) @classmethod def load_dataset_dump(cls, filename): """Loads a compressed data set dump Parameters ---------- filename : string Path to dump file, if without .bz2, the .bz2 extension will be appended. Returns ------- data: dictionary {'X': array-like of array-likes, 'y': array-like of binary label vectors } The dictionary containing the data frame, with 'X' key storing the input space array-like of input feature vectors and 'y' storing labels assigned to each input vector, as a binary indicator vector (i.e. if 5th position has value 1 then the input vector has label no. 5) """ data = None if filename[-4:] != '.bz2': filename += ".bz2" with bz2.BZ2File(filename, "r") as file_handle: data = pickle.load(file_handle) return data scikit-multilearn-0.0.3/skmultilearn/__init__.py0000664000175000017500000000000012724335503023021 0ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/skmultilearn/cluster/0000775000175000017500000000000012724336162022405 5ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/skmultilearn/cluster/__init__.py0000664000175000017500000000071012724335503024512 0ustar niedakhniedakh00000000000000""" The :mod:`skmultilearn.cluster` module gathers label space clustering methods. """ from .base import LabelSpaceClustererBase from .base import LabelCooccurenceClustererBase from .graphtool import GraphToolCooccurenceClusterer from .igraph import IGraphLabelCooccurenceClusterer __all__ = ['LabelSpaceClustererBase', 'LabelCooccurenceClustererBase', 'GraphToolCooccurenceClusterer', 'IGraphLabelCooccurenceClusterer'] scikit-multilearn-0.0.3/skmultilearn/cluster/igraph.py0000664000175000017500000000542312724335503024233 0ustar niedakhniedakh00000000000000from __future__ import absolute_import from .base import LabelCooccurenceClustererBase import numpy as np import igraph as ig class IGraphLabelCooccurenceClusterer(LabelCooccurenceClustererBase): """Clusters the label space using igraph community detection methods Parameters ---------- method : enum from `IGraphLabelCooccurenceClusterer.METHODS` the igraph community detection method that will be used weighted: boolean Decide whether to generate a weighted or unweighted graph. """ METHODS = { 'fastgreedy': lambda graph, w = None: np.array(graph.community_fastgreedy(weights=w).as_clustering()), 'infomap': lambda graph, w = None: np.array(graph.community_infomap(edge_weights=w)), 'label_propagation': lambda graph, w = None: np.array(graph.community_label_propagation(weights=w)), 'leading_eigenvector': lambda graph, w = None: np.array(graph.community_leading_eigenvector(weights=w)), 'multilevel': lambda graph, w = None: np.array(graph.community_multilevel(weights=w)), 'walktrap': lambda graph, w = None: np.array(graph.community_walktrap(weights=w).as_clustering()), } def __init__(self, method=None, weighted=None): super(IGraphLabelCooccurenceClusterer, self).__init__() self.method = method self.is_weighted = weighted if method not in IGraphLabelCooccurenceClusterer.METHODS: raise ValueError( "{} not a supported igraph community detection method".format(method)) if weighted not in [True, False]: raise ValueError("Weighted needs to be a boolean") def fit_predict(self, X, y): """Performs clustering on y and returns list of label lists Builds a label coocurence_graph using :func:`LabelCooccurenceClustererBase.generate_coocurence_adjacency_matrix` on `y` and then detects communities using a selected `method`. Parameters ---------- X : sparse matrix (n_samples, n_features), feature space, not used in this clusterer y : sparse matrix (n_samples, n_labels), label space Returns ------- partition: list of lists : list of lists label indexes, each sublist represents labels that are in that community """ self.generate_coocurence_adjacency_matrix(y) if self.is_weighted: self.weights = dict(weight=self.edge_map.values()) else: self.weights = dict(weight=None) self.coocurence_graph = ig.Graph( edges=[x for x in self.edge_map], vertex_attrs=dict(name=range(1, self.label_count + 1)), edge_attrs=self.weights ) partition = IGraphLabelCooccurenceClusterer.METHODS[ self.method](self.coocurence_graph, self.weights['weight']) return partition scikit-multilearn-0.0.3/skmultilearn/cluster/base.py0000664000175000017500000000341312724335503023670 0ustar niedakhniedakh00000000000000from ..utils import get_matrix_in_format class LabelSpaceClustererBase(object): """docstring for LabelSpaceClustererBase""" def __init__(self): super(LabelSpaceClustererBase, self).__init__() def fit_predict(self, X, y): raise NotImplementedError("LabelSpaceClustererBase::fit_predict()") class LabelCooccurenceClustererBase(LabelSpaceClustererBase): """Base class providing API and common functions for all label cooccurence based multi-label classifiers. Parameters ---------- classifier : scikit classifier type The base classifier that will be used in a class, will be automagically put under self.classifier for future access. weighted: boolean Decide whether to generate a weighted or unweighted graph. """ def __init__(self): super(LabelCooccurenceClustererBase, self).__init__() def generate_coocurence_adjacency_matrix(self, y): """This function generates a weighted or unweighted cooccurence graph based on input binary label vectors and sets it to self.coocurence_graph y : array-like of edges An array-like of binary label vectors. Returns ------- edge_map: dict{ (int, int) : float } Returns a dict of weights """ label_data = get_matrix_in_format(y, 'lil') self.label_count = label_data.shape[1] edge_map = {} for row in label_data.rows: pairs = [(a, b) for b in row for a in row if a < b] for p in pairs: if p not in edge_map: edge_map[p] = 1.0 else: if self.is_weighted: edge_map[p] += 1.0 self.edge_map = edge_map return edge_map scikit-multilearn-0.0.3/skmultilearn/cluster/graphtool.py0000664000175000017500000000631412724335503024760 0ustar niedakhniedakh00000000000000from __future__ import absolute_import from .base import LabelCooccurenceClustererBase import numpy as np import graph_tool.all as gt class GraphToolCooccurenceClusterer(LabelCooccurenceClustererBase): """ Clusters the label space using graph tool's stochastic block modelling community detection method Parameters ---------- weighted: boolean Decide whether to generate a weighted or unweighted graph. allow_overlap: boolean Allow overlapping of clusters or not. """ def __init__(self, weighted=None, allow_overlap=False): super(LabelCooccurenceClustererBase, self).__init__() self.is_weighted = weighted self.allow_overlap = allow_overlap if weighted not in [True, False]: raise ValueError("Weighted needs to be a boolean") if allow_overlap not in [True, False]: raise ValueError("Weighted needs to be a boolean") def generate_coocurence_graph(self): """ Constructs a graph tool Graph object representing the label coocurence_graph Run after self.edge_map has been populated using :func:`LabelCooccurenceClustererBase.generate_coocurence_adjacency_matrix` on `y` in `fit_predict`. The graph is available as self.coocurence_graph, and a weight `double` graphtool.PropertyMap on edges is set as self.weights. Edge weights are all 1.0 if self.weighted is false, otherwise they contain the number of samples that are labelled with the two labels present in the edge. Returns ------- g : graphtool.Graph object representing a label co-occurence graph """ g = gt.Graph(directed=False) g.add_vertex(self.label_count) self.weights = g.new_edge_property('double') for edge, weight in self.edge_map.iteritems(): e = g.add_edge(edge[0], edge[1]) if self.is_weighted: self.weights[e] = weight else: self.weights[e] = 1.0 self.coocurence_graph = g return g def fit_predict(self, X, y): """ Performs clustering on y and returns list of label lists Builds a label coocurence_graph using :func:`LabelCooccurenceClustererBase.generate_coocurence_adjacency_matrix` on `y` and then detects communities using graph tool's stochastic block modeling. Parameters ---------- X : sparse matrix (n_samples, n_features), feature space, not used in this clusterer y : sparse matrix (n_samples, n_labels), label space Returns ------- partition: list of lists : list of lists label indexes, each sublist represents labels that are in that community """ self.generate_coocurence_adjacency_matrix(y) self.generate_coocurence_graph() d = gt.minimize_blockmodel_dl( self.coocurence_graph, overlap=self.allow_overlap, ec=self.weights) A = d.get_blocks().a self.label_sets = [[] for i in xrange(d.B)] for k in xrange(len(A)): self.label_sets[A[k]].append(k) self.model_count = len(self.label_sets) return np.array(self.label_sets) scikit-multilearn-0.0.3/skmultilearn/ensemble/0000775000175000017500000000000012724336162022516 5ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/skmultilearn/ensemble/__init__.py0000664000175000017500000000000012724335503024613 0ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/skmultilearn/ensemble/rakeld.py0000664000175000017500000000241512724335503024332 0ustar niedakhniedakh00000000000000from .partition import LabelSpacePartitioningClassifier import copy import random import numpy as np from scipy import sparse class RakelD(LabelSpacePartitioningClassifier): """Distinct RAndom k-labELsets multi-label classifier.""" def __init__(self, classifier=None, labelset_size=None, require_dense=None): super(RakelD, self).__init__( classifier=classifier, require_dense=require_dense) self.labelset_size = labelset_size self.copyable_attrs = ['labelset_size', 'classifier', 'require_dense'] def generate_partition(self, X, y): """Internal method for sampling k-labELsets""" label_sets = [] self.label_count = y.shape[1] free_labels = xrange(self.label_count) self.model_count = int(np.ceil(self.label_count / self.labelset_size)) while len(label_sets) <= self.model_count: if len(free_labels) == 0: break if len(free_labels) < self.labelset_size: label_sets.append(free_labels) continue label_set = random.sample(free_labels, self.labelset_size) free_labels = list(set(free_labels).difference(set(label_set))) label_sets.append(label_set) self.partition = label_sets scikit-multilearn-0.0.3/skmultilearn/ensemble/rakelo.py0000664000175000017500000000410112724335503024337 0ustar niedakhniedakh00000000000000from .rakeld import RakelD import copy import numpy as np import random from scipy import sparse class RakelO(RakelD): """ Overlapping RAndom k-labELsets multi-label classifier. """ def __init__(self, classifier=None, model_count=None, labelset_size=None, require_dense=None): super(RakelO, self).__init__( classifier=classifier, require_dense=require_dense) self.model_count = int(model_count) self.labelset_size = labelset_size self.copyable_attrs = ['model_count', 'labelset_size', 'require_dense', 'classifier'] def generate_partition(self, X, y): """Internal method for sampling k-labELsets""" label_sets = [] self.label_count = y.shape[1] free_labels = xrange(self.label_count) while len(label_sets) < self.model_count: label_set = random.sample(free_labels, self.labelset_size) if label_set not in label_sets: label_sets.append(label_set) self.partition = label_sets assert len(self.partition) == self.model_count def predict(self, X): """Predict labels for X, see base method's documentation.""" predictions = [ self.ensure_input_format(self.ensure_input_format( c.predict(X)), sparse_format='csc', enforce_sparse=True) for c in self.classifiers ] votes = sparse.csc_matrix( (predictions[0].shape[0], self.label_count), dtype='int') for model in xrange(self.model_count): for label in xrange(len(self.partition[model])): votes[:, self.partition[model][label]] = votes[ :, self.partition[model][label]] + predictions[model][:, label] voters = map(float, votes.sum(axis=0).tolist()[0]) nonzeros = votes.nonzero() for row, column in zip(nonzeros[0], nonzeros[1]): votes[row, column] = np.round( votes[row, column] / float(voters[column])) return self.ensure_input_format(votes, enforce_sparse=False) scikit-multilearn-0.0.3/skmultilearn/ensemble/fixed.py0000664000175000017500000000126512724335503024171 0ustar niedakhniedakh00000000000000from .partition import LabelSpacePartitioningClassifier import copy import random import numpy as np from scipy import sparse class FixedLabelPartitionClassifier(LabelSpacePartitioningClassifier): """Classify given a fixed Label Space partition""" def __init__(self, classifier=None, require_dense=None, partition=None): super(FixedLabelPartitionClassifier, self).__init__( classifier=classifier, require_dense=require_dense) self.partition = partition self.copyable_attrs = ['partition', 'classifier', 'require_dense'] def generate_partition(self, X, y): self.label_count = y.shape[1] self.model_count = len(self.partition) scikit-multilearn-0.0.3/skmultilearn/ensemble/partition.py0000664000175000017500000000340312724335503025077 0ustar niedakhniedakh00000000000000from ..problem_transform.br import BinaryRelevance import copy import numpy as np from scipy import sparse from ..utils import get_matrix_in_format class LabelSpacePartitioningClassifier(BinaryRelevance): """Community detection base classifier Parameters ---------- classifier : scikit classifier type The base classifier that will be used in a class, will be automagically put under self.classifier for future access. clusterer: an skmultilearn.cluster.base object that partitions the output space require_dense : [boolean, boolean] Whether the base classifier requires input as dense arrays, False by default for """ def __init__(self, classifier=None, clusterer=None, require_dense=None): super(LabelSpacePartitioningClassifier, self).__init__( classifier, require_dense) self.clusterer = clusterer self.copyable_attrs = ['clusterer', 'classifier', 'require_dense'] def generate_partition(self, X, y): self.partition = self.clusterer.fit_predict(X, y) self.model_count = len(self.partition) self.label_count = y.shape[1] return self def predict(self, X): """Predict labels for X, see base method's documentation.""" X = self.ensure_input_format( X, sparse_format='csr', enforce_sparse=True) result = sparse.lil_matrix((X.shape[0], self.label_count), dtype=int) for model in xrange(self.model_count): predictions = self.ensure_output_format(self.classifiers[model].predict( X), sparse_format=None, enforce_sparse=True).nonzero() for row, column in zip(predictions[0], predictions[1]): result[row, self.partition[model][column]] = 1 return result scikit-multilearn-0.0.3/skmultilearn/base/0000775000175000017500000000000012724336162021636 5ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/skmultilearn/base/__init__.py0000664000175000017500000000017612724335503023751 0ustar niedakhniedakh00000000000000""".. automodule:: base""" from .base import MLClassifierBase from .problem_transformation import ProblemTransformationBase scikit-multilearn-0.0.3/skmultilearn/base/mock.py0000664000175000017500000000056312724335503023143 0ustar niedakhniedakh00000000000000from .base import MLClassifierBase class MockClassifier(MLClassifierBase): """docstring for MockClassifier""" def __init__(self): super(MockClassifier, self).__init__() def fit(X, y): self.label_count = y.shape[1] return self def predict(X): return csr_matrix(np.ones(shape=(X.shape[0], self.label_count), dtype=int)) scikit-multilearn-0.0.3/skmultilearn/base/base.py0000664000175000017500000002105512724335503023123 0ustar niedakhniedakh00000000000000import copy import numpy as np from ..utils import get_matrix_in_format, matrix_creation_function_for_format from scipy.sparse import issparse, csr_matrix from sklearn.base import BaseEstimator, ClassifierMixin class MLClassifierBase(BaseEstimator, ClassifierMixin): """Base class providing API and common functions for all multi-label classifiers. Parameters ---------- classifier : scikit classifier type The base classifier that will be used in a class, will be automagically put under self.classifier for future access. require_dense : boolean Whether the base classifier requires input as dense arrays, False by default """ def __init__(self): super(MLClassifierBase, self).__init__() self.copyable_attrs = [] def generate_data_subset(self, y, subset, axis): """This function subsets the array of binary label vectors to include only certain labels. Parameters ---------- y : array-like of array-likes An array-like of binary label vectors. subset: array-like of integers array of integers, indices that will be subsetted from array-likes in y axis: integer 0 for 'rows', 1 for 'labels', control variable for whether to return rows or labels as indexed by subset Returns ------- multi-label binary label vector : array-like of array-likes of {0,1} array of binary label vectors including label data only for labels from parameter labels """ return_data = None if axis == 1: return_data = y.tocsc()[:, subset] elif axis == 0: return_data = y.tocsr()[subset, :] return return_data def ensure_input_format(self, X, sparse_format='csr', enforce_sparse=False): """This function ensures that input format follows the density/sparsity requirements of base classifier. Parameters ---------- X : array-like or sparse matrix, shape = [n_samples, n_features] An input feature matrix sparse_format: string Requested format of returned scipy.sparse matrix, if sparse is returned enforce_sparse : bool Ignore require_dense and enforce sparsity, useful internally Returns ------- transformed X : array-like or sparse matrix, shape = [n_samples, n_features] If require_dense was set to true for input features in the constructor, the returned value is an array-like of array-likes. If require_dense is set to false, a sparse matrix of format sparse_format is returned, if possible - without cloning. """ is_sparse = issparse(X) if is_sparse: if self.require_dense[0] and not enforce_sparse: return X.toarray() else: if sparse_format is None: return X else: return get_matrix_in_format(X, sparse_format) else: if self.require_dense[0] and not enforce_sparse: # TODO: perhaps a check_array? return X else: return matrix_creation_function_for_format(sparse_format)(X) def ensure_output_format(self, y, sparse_format='csr', enforce_sparse=False): """This function ensures that output format follows the density/sparsity requirements of base classifier. Parameters ---------- y : array-like with shape = [n_samples] or [n_samples, n_outputs]; or sparse matrix, shape = [n_samples, n_outputs] An input feature matrix sparse_format: string Requested format of returned scipy.sparse matrix, if sparse is returned enforce_sparse : bool Ignore require_dense and enforce sparsity, useful internally Returns ------- transformed y: array-like with shape = [n_samples] or [n_samples, n_outputs]; or sparse matrix, shape = [n_samples, n_outputs] If require_dense was set to True for input features in the constructor, the returned value is an array-like of array-likes. If require_dense is set to False, a sparse matrix of format sparse_format is returned, if possible - without cloning. """ is_sparse = issparse(y) if is_sparse: if self.require_dense[1] and not enforce_sparse: if y.shape[1] != 1: return y.toarray() elif y.shape[1] == 1: return np.ravel(y.toarray()) else: if sparse_format is None: return y else: return get_matrix_in_format(y, sparse_format) else: if self.require_dense[1] and not enforce_sparse: # ensuring 1d if len(y[0]) == 1: return np.ravel(y) else: return y else: return matrix_creation_function_for_format(sparse_format)(y) def fit(self, X, y): """Abstract class to implement to fit classifier according to X,y. Parameters ---------- X : {array-like, sparse matrix}, shape = [n_samples, n_features] Training vectors, where n_samples is the number of samples and n_features is the number of features. y : array-like, shape = [n_samples, n_labels] Binary label vectors with 1 if label should be applied and 0 if not. Returns ------- self : object Returns self. """ raise NotImplementedError("MLClassifierBase::fit()") def predict(self, X): """Abstract class to implement to perform classification on an array of test vectors X. Parameters ---------- X : {array-like, sparse matrix}, shape = [n_samples, n_features] Training vectors, where n_samples is the number of samples and n_features is the number of features. Returns ------- y : array-like, shape = [n_samples, n_labels] Binary label vectors with 1 if label should be applied and 0 if not. n_labels is number of labels in the multi-label instance that the classifier was fit to. """ raise NotImplementedError("MLClassifierBase::predict()") def get_params(self, deep=True): """ Introspection of classifier for search models like cross validation and grid search. Parameters ---------- deep : boolean If true all params will be introspected also and appended to the output dict. Returns ------- out : dictionary Dictionary of all parameters and their values. If deep=True the dictionary also holds the parameters of the parameters. """ out = dict() for attr in self.copyable_attrs: out[attr] = getattr(self, attr) if hasattr(getattr(self, attr), 'get_params') and deep: deep_items = getattr(self, attr).get_params().items() out.update((attr + '__' + k, val) for k, val in deep_items) return out def set_params(self, **parameters): """ Set parameters as returned by `get_params`. @see https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/base.py#L243 """ if not parameters: return self valid_params = self.get_params(deep=True) for parameter, value in parameters.items(): split = parameter.split('__', 1) if len(split) > 1: sub_obj_name, sub_param = split if sub_obj_name not in valid_params: raise ValueError('Invalid parameter %s for estimator %s. ' 'Check the list of available parameters ' 'with `estimator.get_params().keys()`.' % (name, self)) sub_object = valid_params[sub_obj_name] sub_object.set_params(**{sub_param: value}) else: if parameter in valid_params: setattr(self, parameter, value) else: raise ValueError('Invalid parameter %s for estimator %s. ' 'Check the list of available parameters ' 'with `estimator.get_params().keys()`.' % (name, self)) return self scikit-multilearn-0.0.3/skmultilearn/base/problem_transformation.py0000664000175000017500000001061512724335503026777 0ustar niedakhniedakh00000000000000import copy import numpy as np from .base import MLClassifierBase from ..utils import get_matrix_in_format, matrix_creation_function_for_format from scipy.sparse import issparse, csr_matrix from sklearn.base import BaseEstimator, ClassifierMixin class ProblemTransformationBase(MLClassifierBase): """Base class providing common functions for multi-label classifiers that follow the problem transformation approach. Problem transformation is the approach in which the original multi-label classification problem is transformed into one or more single-label problems, which are then solved by single-class or multi-class classifiers. Scikit-multilearn provides a number of such methods: - Binary Relevance - which performs a single-label single-class classification for each label and sums the results :class:`BinaryRelevance` - Classifier Chains - which performs a single-label single-class classification for each label and sums the results :class:`ClassifierChain` - Label Powerset - which performs a single-label single-class classification for each label and sums the results :class:`LabelPowerset` Parameters ---------- classifier : scikit classifier type The base classifier that will be used in a class, will be automagically put under self.classifier for future access. require_dense : boolean Whether the base classifier requires input as dense arrays, False by default """ def __init__(self, classifier=None, require_dense=None): super(ProblemTransformationBase, self).__init__() self.copyable_attrs = ["classifier", "require_dense"] self.classifier = classifier if require_dense is not None: if isinstance(require_dense, bool): self.require_dense = [require_dense, require_dense] else: assert len(require_dense) == 2 and isinstance( require_dense[0], bool) and isinstance(require_dense[1], bool) self.require_dense = require_dense else: if isinstance(self.classifier, MLClassifierBase): self.require_dense = [False, False] else: self.require_dense = [True, True] def get_params(self, deep=True): """ Introspection of classifier for search models like cross validation and grid search. Parameters ---------- deep : boolean If true all params will be introspected also and appended to the output dict. Returns ------- out : dictionary Dictionary of all parameters and their values. If deep=True the dictionary also holds the parameters of the parameters. """ out = dict() for attr in self.copyable_attrs: out[attr] = getattr(self, attr) if hasattr(getattr(self, attr), 'get_params') and deep: deep_items = getattr(self, attr).get_params().items() out.update((attr + '__' + k, val) for k, val in deep_items) return out def set_params(self, **parameters): """ Set parameters as returned by `get_params`. @see https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/base.py#L243 """ if not parameters: return self valid_params = self.get_params(deep=True) for parameter, value in parameters.items(): split = parameter.split('__', 1) if len(split) > 1: sub_obj_name, sub_param = split if sub_obj_name not in valid_params: raise ValueError('Invalid parameter %s for estimator %s. ' 'Check the list of available parameters ' 'with `estimator.get_params().keys()`.' % (name, self)) sub_object = valid_params[sub_obj_name] sub_object.set_params(**{sub_param: value}) else: if parameter in valid_params: setattr(self, parameter, value) else: raise ValueError('Invalid parameter %s for estimator %s. ' 'Check the list of available parameters ' 'with `estimator.get_params().keys()`.' % (name, self)) return self scikit-multilearn-0.0.3/skmultilearn/problem_transform/0000775000175000017500000000000012724336162024457 5ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/skmultilearn/problem_transform/lp.py0000664000175000017500000000421212724335503025441 0ustar niedakhniedakh00000000000000from ..base.problem_transformation import ProblemTransformationBase import numpy as np from scipy import sparse class LabelPowerset(ProblemTransformationBase): """Label Powerset multi-label classifier.""" BRIEFNAME = "LP" def __init__(self, classifier=None, require_dense=None): super(LabelPowerset, self).__init__( classifier=classifier, require_dense=require_dense) self.clean() def clean(self): self.unique_combinations = {} self.reverse_combinations = [] self.label_count = None def fit(self, X, y): """Fit classifier according to X,y, see base method's documentation.""" X = self.ensure_input_format( X, sparse_format='csr', enforce_sparse=True) y = self.ensure_output_format( y, sparse_format='lil', enforce_sparse=True) self.clean() self.label_count = y.shape[1] last_id = 0 train_vector = [] for labels_applied in y.rows: label_string = ",".join(map(str, labels_applied)) if label_string not in self.unique_combinations: self.unique_combinations[label_string] = last_id self.reverse_combinations.append(labels_applied) last_id += 1 train_vector.append(self.unique_combinations[label_string]) self.classifier.fit(self.ensure_input_format(X), train_vector) return self def predict(self, X): """Predict labels for X, see base method's documentation.""" # this will be an np.array of integers representing classes lp_prediction = self.classifier.predict(self.ensure_input_format(X)) result = sparse.lil_matrix((X.shape[0], self.label_count), dtype='i8') for row in xrange(len(lp_prediction)): assignment = lp_prediction[row] result[row, self.reverse_combinations[assignment]] = 1 return result def transform(self, y): """ Transform the label set to a multi-class problem """ return map(lambda x: int("".join(map(str, x))), y) def inverse_transform(self, y): return map(lambda x: map(int, str(x)), y) scikit-multilearn-0.0.3/skmultilearn/problem_transform/__init__.py0000664000175000017500000000013612724335503026566 0ustar niedakhniedakh00000000000000from .br import BinaryRelevance from .cc import ClassifierChain from .lp import LabelPowerset scikit-multilearn-0.0.3/skmultilearn/problem_transform/cc.py0000664000175000017500000000362512724335503025422 0ustar niedakhniedakh00000000000000from ..base.problem_transformation import ProblemTransformationBase from scipy.sparse import hstack, coo_matrix, issparse import copy import numpy as np import random class ClassifierChain(ProblemTransformationBase): """Classifier Chains multi-label classifier.""" BRIEFNAME = "CC" def __init__(self, classifier=None, require_dense=False): super(ClassifierChain, self).__init__(classifier, require_dense) def fit(self, X, y): # fit L = len(y[0]) BR classifiers h_i # on X + y[:i] as input space and y[i+1] as output # X_extended = self.ensure_input_format( X, sparse_format='csc', enforce_sparse=True) y = self.ensure_output_format( y, sparse_format='csc', enforce_sparse=True) self.label_count = y.shape[1] print self.label_count self.classifiers = [None for x in xrange(self.label_count)] for label in xrange(self.label_count): classifier = copy.deepcopy(self.classifier) y_subset = self.generate_data_subset(y, label, axis=1) print label, X_extended.shape self.classifiers[label] = classifier.fit(self.ensure_input_format( X_extended), self.ensure_output_format(y_subset)) X_extended = hstack([X_extended, y_subset]) return self def predict(self, X): X_extended = self.ensure_input_format( X, sparse_format='csc', enforce_sparse=True) prediction = None for label in xrange(self.label_count): print label, X_extended.shape prediction = self.classifiers[label].predict( self.ensure_input_format(X_extended)) prediction = self.ensure_output_format( prediction, sparse_format='csc', enforce_sparse=True) X_extended = hstack([X_extended, prediction.T]).tocsc() return X_extended[:, -self.label_count:] scikit-multilearn-0.0.3/skmultilearn/problem_transform/br.py0000664000175000017500000000320712724335503025434 0ustar niedakhniedakh00000000000000from ..base.problem_transformation import ProblemTransformationBase from scipy.sparse import hstack, coo_matrix from sklearn.utils import check_array import copy class BinaryRelevance(ProblemTransformationBase): """Binary Relevance multi-label classifier.""" BRIEFNAME = "BR" def __init__(self, classifier=None, require_dense=None): super(BinaryRelevance, self).__init__(classifier, require_dense) def generate_partition(self, X, y): self.partition = range(y.shape[1]) self.model_count = y.shape[1] def fit(self, X, y): """Fit classifier according to `X`, `y`, see base method's documentation.""" X = self.ensure_input_format( X, sparse_format='csr', enforce_sparse=True) y = self.ensure_output_format( y, sparse_format='csc', enforce_sparse=True) self.generate_partition(X, y) self.classifiers = [] for i in xrange(self.model_count): classifier = copy.deepcopy(self.classifier) y_subset = self.generate_data_subset(y, self.partition[i], axis=1) classifier.fit(self.ensure_input_format( X), self.ensure_output_format(y_subset)) self.classifiers.append(classifier) return self def predict(self, X): """Predict labels for `X`, see base method's documentation.""" predictions = [self.classifiers[label].predict( self.ensure_input_format(X)) for label in xrange(self.model_count)] if isinstance(self.classifier, ProblemTransformationBase): return hstack(predictions) else: return coo_matrix(predictions).T scikit-multilearn-0.0.3/skmultilearn/utils.py0000664000175000017500000000123312724335503022433 0ustar niedakhniedakh00000000000000import scipy.sparse as sp def get_matrix_in_format(original_matrix, matrix_format): if original_matrix.getformat() == matrix_format: return original_matrix return original_matrix.asformat(matrix_format) def matrix_creation_function_for_format(sparse_format): SPARSE_FORMAT_TO_CONSTRUCTOR = { "bsr": sp.bsr_matrix, "coo": sp.coo_matrix, "csc": sp.csc_matrix, "csr": sp.csr_matrix, "dia": sp.dia_matrix, "dok": sp.dok_matrix, "lil": sp.lil_matrix } if sparse_format not in SPARSE_FORMAT_TO_CONSTRUCTOR: return None return SPARSE_FORMAT_TO_CONSTRUCTOR[sparse_format] scikit-multilearn-0.0.3/skmultilearn/ext/0000775000175000017500000000000012724336162021524 5ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/skmultilearn/ext/__init__.py0000664000175000017500000000002712724335503023632 0ustar niedakhniedakh00000000000000from .meka import Meka scikit-multilearn-0.0.3/skmultilearn/ext/meka.py0000664000175000017500000002222512724335503023014 0ustar niedakhniedakh00000000000000import subprocess import tempfile import shlex import scipy.sparse as sparse import arff import os from ..base import MLClassifierBase from ..dataset import Dataset class Meka(MLClassifierBase): """.. autoclass:: skmultilearn.ext.Meka Runs the MEKA classifier Parameters ---------- meka_classifier : string The MEKA classifier string and parameters from the MEKA API, such as: "meka.classifiers.multilabel.MULAN -S RAkEL2" weka_classifier : string The WEKA classifier string and parameters from the WEKA API, such as: "weka.classifiers.trees.J48" java_command : string Path to test the java command meka_classpath: string Path to the MEKA class path folder, usually the folder lib in the directory MEKA was extracted to """ def __init__(self, meka_classifier=None, weka_classifier=None, java_command=None, meka_classpath=None): super(Meka, self).__init__() self.java_command = java_command if self.java_command is None: # TODO: this will not be needed once we're python 3 ready - we will # use it only in python 2.7 cases from whichcraft import which self.java_command = which("java") if self.java_command is None: raise ValueError("Java not found") self.meka_classpath = meka_classpath if self.meka_classpath is None: self.meka_classpath = os.environ.get('MEKA_CLASSPATH') if self.meka_classpath is None: raise ValueError("No meka classpath defined") self.meka_classifier = meka_classifier self.verbosity = 5 self.weka_classifier = weka_classifier self.output = None self.warnings = None self.require_dense = [False, False] self.copyable_attrs = ['meka_classifier', 'weka_classifier', 'java_command', 'meka_classpath'] self.clean() def clean(self): self.results = None self.statistics = None self.output = None self.error = None self.label_count = None self.instance_count = None def remove_temporary_files(self, temporary_files): for file_name in temporary_files: os.remove(file_name.name) arff_file_name = file_name.name + '.arff' if os.path.exists(arff_file_name): os.remove(arff_file_name) def run_meka_command(self, args): command_args = [ self.java_command, '-cp', "{}*".format(self.meka_classpath), self.meka_classifier, ] if self.weka_classifier is not None: command_args += ['-W', self.weka_classifier] command_args += args meka_command = " ".join(command_args) pipes = subprocess.Popen(shlex.split( meka_command), stdout=subprocess.PIPE, stderr=subprocess.PIPE) self.output, self.error = pipes.communicate() if pipes.returncode != 0: raise Exception, self.output def fit(self, X, y): self.clean() X = self.ensure_input_format( X, sparse_format='dok', enforce_sparse=True) y = self.ensure_output_format( y, sparse_format='dok', enforce_sparse=True) self.label_count = y.shape[1] # we need this in case threshold needs to be recalibrated in meka self.train_data_ = Dataset.save_to_arff(X, y) train_arff = tempfile.NamedTemporaryFile(delete=False) classifier_dump_file = tempfile.NamedTemporaryFile(delete=False) try: with open(train_arff.name + '.arff', 'w') as fp: fp.write(self.train_data_) input_args = [ '-verbosity', "0", '-split-percentage', "100", '-t', train_arff.name + '.arff', '-d', classifier_dump_file.name, ] self.run_meka_command(input_args) self.classifier_dump = None with open(classifier_dump_file.name, 'rb') as fp: self.classifier_dump = fp.read() finally: self.remove_temporary_files([train_arff, classifier_dump_file]) return self def predict(self, X): X = self.ensure_input_format( X, sparse_format='dok', enforce_sparse=True) self.instance_count = X.shape[0] if self.classifier_dump is None: raise Exception, 'Not classified' sparse_y = sparse.coo_matrix((X.shape[0], self.label_count), dtype=int) try: train_arff = tempfile.NamedTemporaryFile(delete=False) test_arff = tempfile.NamedTemporaryFile(delete=False) classifier_dump_file = tempfile.NamedTemporaryFile(delete=False) with open(train_arff.name + '.arff', 'wb') as fp: fp.write(self.train_data_) with open(classifier_dump_file.name, 'wb') as fp: fp.write(self.classifier_dump) with open(test_arff.name + '.arff', 'wb') as fp: fp.write(Dataset.save_to_arff(X, sparse_y)) args = [ '-l', classifier_dump_file.name ] self.run(train_arff.name + '.arff', test_arff.name + '.arff', args) self.parse_output() finally: self.remove_temporary_files( [train_arff, test_arff, classifier_dump_file]) return self.results def run(self, train_file, test_file, additional_arguments=[]): """ Runs the meka classifiers Parameters ---------- train_file : string Path to train .arff file in meka format (big endian, labels first in attributes list). test_file : string Path to test .arff file in meka format (big endian, labels first in attributes list). Returns ------- predictions: sparse binary indicator matrix [n_test_samples, n_labels] array of binary label vectors including label predictions """ self.output = None self.warnings = None # meka_command_string = 'java -cp "/home/niedakh/pwr/old/meka-1.5/lib/*" meka.classifiers.multilabel.MULAN -S RAkEL2 # -threshold 0 -t {train} -T {test} -verbosity {verbosity} -W weka.classifiers.bayes.NaiveBayes' # meka.classifiers.multilabel.LC, weka.classifiers.bayes.NaiveBayes args = [ '-t', train_file, '-T', test_file, '-verbosity', str(5), ] + additional_arguments self.run_meka_command(args) return self def parse_output(self): """ Internal function for parsing MEKA output.""" if self.output is None: self.results = None self.statistics = None return None print self.output predictions_split_head = '==== PREDICTIONS' predictions_split_foot = '|===========' if self.label_count is None: self.label_count = map(lambda y: int(y.split(')')[1].strip()), filter( lambda x: 'Number of labels' in x, self.output.split('\n')))[0] if self.instance_count is None: self.instance_count = int(float(filter(lambda x: '==== PREDICTIONS (N=' in x, self.output.split( '\n'))[0].split('(')[1].split('=')[1].split(')')[0])) self.predictions = self.output.split(predictions_split_head)[1].split( predictions_split_foot)[0].split('\n')[1:-1] self.predictions = map(lambda z: map(lambda f: int(f.strip()), z.split(',')), map( lambda y: y.split(']')[0], map(lambda x: x.split('] [')[1], self.predictions))) if self.verbosity == 6: self.results = sparse.csr_matrix(self.predictions) elif self.verbosity == 5: self.results = sparse.lil_matrix( (self.instance_count, self.label_count), dtype='int') for row in xrange(self.instance_count): for label in self.predictions[row]: self.results[row, label] = 1 statistics = filter(lambda x: len(x) > 0 and '==' not in x, self.output.split( '== Evaluation Info')[1].split('\n')) statistics = filter(lambda y: ' ' in y, map( lambda z: z.strip(), statistics)) array_data = filter(lambda z: '[' in z, statistics) non_array_data = filter(lambda z: '[' not in z, statistics) self.statistics = {} for row in non_array_data: r = row.strip().split(' ') r = filter(lambda z: len(z) > 0, r) r = map(lambda z: z.strip(), r) if len(r) < 2: continue try: test_value = float(r[1]) except ValueError: test_value = r[1] r[1] = test_value self.statistics[r[0]] = r[1] for row in array_data: r = row.strip().split('[') r = map(lambda z: z.strip(), r) r[1] = r[1].replace(', ', ' ').replace( ',', '.').replace(']', '').split(' ') r[1] = filter(lambda x: len(x) > 0, r[1]) self.statistics[r[0]] = r[1] return self.results, self.statistics scikit-multilearn-0.0.3/CHANGES.txt0000664000175000017500000000223512724335621020024 0ustar niedakhniedakh00000000000000scikit-multilearn - 0.0.3 (released 2016-06-04) - add Classifier Chains support based on Wojciech Stachowiak's code - [LargeSpeedup] converted all classes to use sparse matrices inside scikit-multilearn - converted all methods to be fully compatible with scikit BaseEstimator & Classifier Mixin based on work Christian Schulze's work - refactor meka to perform as a scikit-compatible classifier - add support for meka 1.9 - add framework for label space division based classification and label space clustering version of the ClustererMixin from scikit - add igraph and graphtool-based label space clusterers using community detection methods on a label co-occurence graph - full test coverage - fixed a number of bugs scikit-multilearn - 0.0.2 (released 2016-06-04) Broken release due to PYPI absurds. scikit-multilearn - 0.0.1 (released 2014-12-01) - initial release - support for initial set of multi-label classification methods: - binary relevance, label powerset - RAkEL both distinct and overlapping - label cooccurence based distinct partitioning classifiers - interface to meka 1.7 - ARFF to numpy.array convertion classes and data set manipulation scikit-multilearn-0.0.3/scikit_multilearn.egg-info/0000775000175000017500000000000012724336162023426 5ustar niedakhniedakh00000000000000scikit-multilearn-0.0.3/scikit_multilearn.egg-info/PKG-INFO0000664000175000017500000000166412724336161024531 0ustar niedakhniedakh00000000000000Metadata-Version: 1.1 Name: scikit-multilearn Version: 0.0.3 Summary: A set of python modules for multi-label classification Home-page: http://scikit-multilearn.github.io/ Author: Piotr Szymański Author-email: niedakh@gmail.com License: BSD Description: UNKNOWN Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Environment :: Console Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: Intended Audience :: Education Classifier: Intended Audience :: Science/Research Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: Microsoft :: Windows Classifier: Operating System :: POSIX Classifier: Programming Language :: Python Classifier: Topic :: Scientific/Engineering Classifier: Topic :: Scientific/Engineering :: Information Analysis Classifier: Topic :: Scientific/Engineering :: Bio-Informatics scikit-multilearn-0.0.3/scikit_multilearn.egg-info/top_level.txt0000664000175000017500000000001512724336161026153 0ustar niedakhniedakh00000000000000skmultilearn scikit-multilearn-0.0.3/scikit_multilearn.egg-info/SOURCES.txt0000664000175000017500000000162712724336162025320 0ustar niedakhniedakh00000000000000CHANGES.txt MANIFEST.in requirements.txt setup.cfg setup.py scikit_multilearn.egg-info/PKG-INFO scikit_multilearn.egg-info/SOURCES.txt scikit_multilearn.egg-info/dependency_links.txt scikit_multilearn.egg-info/top_level.txt skmultilearn/__init__.py skmultilearn/dataset.py skmultilearn/utils.py skmultilearn/base/__init__.py skmultilearn/base/base.py skmultilearn/base/mock.py skmultilearn/base/problem_transformation.py skmultilearn/cluster/__init__.py skmultilearn/cluster/base.py skmultilearn/cluster/graphtool.py skmultilearn/cluster/igraph.py skmultilearn/ensemble/__init__.py skmultilearn/ensemble/fixed.py skmultilearn/ensemble/partition.py skmultilearn/ensemble/rakeld.py skmultilearn/ensemble/rakelo.py skmultilearn/ext/__init__.py skmultilearn/ext/meka.py skmultilearn/problem_transform/__init__.py skmultilearn/problem_transform/br.py skmultilearn/problem_transform/cc.py skmultilearn/problem_transform/lp.pyscikit-multilearn-0.0.3/scikit_multilearn.egg-info/dependency_links.txt0000664000175000017500000000000112724336161027473 0ustar niedakhniedakh00000000000000 scikit-multilearn-0.0.3/MANIFEST.in0000664000175000017500000000005212724335503017743 0ustar niedakhniedakh00000000000000include *.txt recursive-include docs *.txtscikit-multilearn-0.0.3/setup.cfg0000664000175000017500000000026712724336162020040 0ustar niedakhniedakh00000000000000[build_sphinx] source-dir = docs/source build-dir = docs/build all_files = 1 [upload_sphinx] upload-dir = docs/build/html [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 scikit-multilearn-0.0.3/requirements.txt0000664000175000017500000000020512724335503021471 0ustar niedakhniedakh00000000000000liac-arff==2.1.0 base64 bz2 copy igraph numpy pickle pkgutil random shlex shutil subprocess sys tempfile unittest scipy scikit-learn scikit-multilearn-0.0.3/setup.py0000664000175000017500000000225112724335552017726 0ustar niedakhniedakh00000000000000# -*- coding: utf-8 -*- from setuptools import setup, find_packages #import sphinx_pypi_upload setup( name='scikit-multilearn', version='0.0.3', packages=find_packages(exclude=['docs', 'tests', '*.tests']), author=u'Piotr Szymański', author_email='niedakh@gmail.com', license='BSD', # long_description=open('README.md').read(), url='http://scikit-multilearn.github.io/', description= 'A set of python modules for multi-label classification', classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: Console', 'Environment :: Web Environment', 'Intended Audience :: Developers', 'Intended Audience :: Education', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: BSD License', 'Operating System :: MacOS :: MacOS X', 'Operating System :: Microsoft :: Windows', 'Operating System :: POSIX', 'Programming Language :: Python', 'Topic :: Scientific/Engineering', 'Topic :: Scientific/Engineering :: Information Analysis', 'Topic :: Scientific/Engineering :: Bio-Informatics', ], )