python-weka-wrapper-0.2.2/0000755017267001726700000000000012452374314017074 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.2.2/python/0000755017267001726700000000000012452374314020415 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.2.2/python/python_weka_wrapper.egg-info/0000755017267001726700000000000012452374314026177 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.2.2/python/python_weka_wrapper.egg-info/dependency_links.txt0000644017267001726700000000000112452374314032245 0ustar fracpetefracpete00000000000000 python-weka-wrapper-0.2.2/python/python_weka_wrapper.egg-info/requires.txt0000644017267001726700000000007612452374314030602 0ustar fracpetefracpete00000000000000javabridge>=1.0.9 [plots] matplotlib [graphs] pygraphviz PILpython-weka-wrapper-0.2.2/python/python_weka_wrapper.egg-info/SOURCES.txt0000644017267001726700000000206112452374314030062 0ustar fracpetefracpete00000000000000CHANGES.rst DESCRIPTION.rst MANIFEST.in setup.cfg setup.py python/python_weka_wrapper.egg-info/PKG-INFO python/python_weka_wrapper.egg-info/SOURCES.txt python/python_weka_wrapper.egg-info/dependency_links.txt python/python_weka_wrapper.egg-info/requires.txt python/python_weka_wrapper.egg-info/top_level.txt python/weka/__init__.py python/weka/associations.py python/weka/attribute_selection.py python/weka/classifiers.py python/weka/clusterers.py python/weka/datagenerators.py python/weka/experiments.py python/weka/filters.py python/weka/core/__init__.py python/weka/core/capabilities.py python/weka/core/classes.py python/weka/core/converters.py python/weka/core/dataset.py python/weka/core/jvm.py python/weka/core/packages.py python/weka/core/serialization.py python/weka/core/types.py python/weka/core/utils.py python/weka/core/version.py python/weka/lib/python-weka-wrapper-src.jar python/weka/lib/python-weka-wrapper.jar python/weka/plot/__init__.py python/weka/plot/classifiers.py python/weka/plot/clusterers.py python/weka/plot/dataset.py python/weka/plot/graph.pypython-weka-wrapper-0.2.2/python/python_weka_wrapper.egg-info/top_level.txt0000644017267001726700000000000512452374314030724 0ustar fracpetefracpete00000000000000weka python-weka-wrapper-0.2.2/python/python_weka_wrapper.egg-info/PKG-INFO0000644017267001726700000001103112452374314027270 0ustar fracpetefracpete00000000000000Metadata-Version: 1.1 Name: python-weka-wrapper Version: 0.2.2 Summary: Python wrapper for the Weka Machine Learning Workbench Home-page: https://github.com/fracpete/python-weka-wrapper Author: Peter "fracpete" Reutemann Author-email: pythonwekawrapper at gmail dot com License: GNU General Public License version 3.0 (GPLv3) Description: The **python-weka-wrapper** package makes it easy to run Weka algorithms and filters from within Python. It offers access to Weka API using thin wrappers around JNI calls using the **javabridge** package. Changelog ========= 0.2.2 (2015-01-05) ------------------ - added convenience methods `no_class` (to unset class) and `has_class` (class set?) to `Instances` class - switched to using faster method objects for methods `classify_instance`/`distribution_for_instance` in `Classifier` class - switched to using faster method objects for methods `cluster_instance`/`distribution_for_instance` in `Clusterer` class - switched to using faster method objects for methods `class_index`, `is_missing`, `get/set_value`, `get/set_string_value`, `weight` in `Instance` class - switched to using faster method objects for methods `input`, `output`, `outputformat` in `Filter` class - switched to using faster method objects for methods `attribute`, `attribute_by_name`, `num_attributes`, `num_instances`, `class_index`, `class_attribute`, `set_instance`, `get_instance`, `add_instance` in `Instances` class 0.2.1 (2015-01-05) ------------------ - added unit testing framework - added method `refresh_cache()` to `weka/core/packages.py` to allow user to refresh local cache - method `get_classname` in `weka.core.utils` now handles Python objects and class objects as well - added convenience method `get_jclass` to `weka.core.utils` to instantiate a Java class - added a `JavaArray` wrapper for `arrays`, which allows getting/setting elements and iterating - added property `classname` to class `JavaObject` for easy access to classname of underlying object - added class method `parse_matlab` for parsing Matlab matrix strings to `CostMatrix` class - `predictions` method of `Evaluation` class now return `None` if predictions are discarded - `Associator.get_capabilities()` method is now a property: `Associator.capabilities` - added wrapper classes for Java enums: `weka.core.classes.Enum` - fixed retrieval of `sumSq` in `Stats` class (used by `AttributeStats`) - fixed `cluster_instance` method in `Clusterer` class - fixed `filter` and `clusterer` properties in clusterer classes (`SingleClustererEnhancer`, `FilteredClusterer`) - added `crossvalidate_model` method to `ClusterEvaluation` - added `get_prc` method to `plot/classifiers.py` for calculating the area under the precision-recall curve - `Filter.filter` method now handles list of `Instances` objects as well, applying the filter sequentially to all the datasets (allows generation of compatible train/test sets) 0.2.0 (2014-12-22) ------------------ NB: This release is not backwards compatible! - requires `JavaBridge` 1.0.9 at least - moved from Java-like get/set (`getIndex()` and `setIndex(int)`) to nicer Python properties - using Python properties (also only read-only ones) wherevere possible - added `weka.core.version` for accessing the Weka version currently in use - added `jwrapper` and `jclasswrapper` methods to `JavaObject` class (the mother of all objects in python-weka-wrapper) to allow generic access to an object's methods: http://pythonhosted.org//javabridge/highlevel.html#wrapping-java-objects-using-reflection - added convenience methods `class_is_last()` and `class_is_first()` to `weka.core.Instances` class - added convenience methods `delete_last_attribute()` and `delete_first_attribute()` to `weka.core.Instances` class Older releases -------------- https://github.com/fracpete/python-weka-wrapper/blob/7fd0bba3c74277313eb463e338c1a7e117a1ea22/CHANGES.rst Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: License :: OSI Approved :: GNU General Public License (GPL) Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence Classifier: Programming Language :: Python python-weka-wrapper-0.2.2/python/weka/0000755017267001726700000000000012452374314021344 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.2.2/python/weka/experiments.py0000644017267001726700000006233212446346264024275 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # experiments.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import logging import javabridge import weka.core.utils as utils from weka.core.classes import OptionHandler, Range from weka.core.dataset import Instances from weka.classifiers import Classifier # logging setup logger = logging.getLogger("weka.experiments") class Experiment(OptionHandler): """ Wrapper class for an experiment. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified experiment using either the classname or the supplied JB_Object. :param classname: the classname of the experiment :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to use :type options: list """ if jobject is None: jobject = Experiment.new_instance(classname) super(Experiment, self).__init__(jobject=jobject, options=options) class SimpleExperiment(OptionHandler): """ Ancestor for simple experiments. See following URL for how to use the Experiment API: http://weka.wikispaces.com/Using+the+Experiment+API """ def __init__(self, datasets, classifiers, jobject=None, classification=True, runs=10, result=None): """ Initializes the experiment. :param datasets: the filenames of datasets to use in the experiment :type datasets: list :param classifiers: the Classifier objects or commandline strings to use in the experiment :type classifiers: list :param jobject: the Java Object to use :type jobject: JB_Object :param classification: whether to perform classification or regression :type classification:bool :param runs: the number of runs to perform :type runs: int :param result: the filename of the file to store the results in :type result: str """ if not jobject is None: self.enforce_type(jobject, "weka.experiment.Experiment") if jobject is None: jobject = javabridge.make_instance("weka/experiment/Experiment", "()V") self.classification = classification self.runs = runs self.datasets = datasets[:] self.classifiers = classifiers[:] self.result = result super(SimpleExperiment, self).__init__(jobject=jobject) def configure_splitevaluator(self): """ Configures and returns the SplitEvaluator and Classifier instance as tuple. :return: evaluator and classifier :rtype: tuple """ if self.classification: speval = javabridge.make_instance("weka/experiment/ClassifierSplitEvaluator", "()V") else: speval = javabridge.make_instance("weka/experiment/RegressionSplitEvaluator", "()V") classifier = javabridge.call(speval, "getClassifier", "()Lweka/classifiers/Classifier;") return speval, classifier def configure_resultproducer(self): """ Configures and returns the ResultProducer and PropertyPath as tuple. :return: producer and property path :rtype: tuple """ raise Exception("Not implemented!") def setup(self): """ Initializes the experiment. """ # basic options javabridge.call( self.jobject, "setPropertyArray", "(Ljava/lang/Object;)V", javabridge.get_env().make_object_array(0, javabridge.get_env().find_class("weka/classifiers/Classifier"))) javabridge.call( self.jobject, "setUsePropertyIterator", "(Z)V", True) javabridge.call( self.jobject, "setRunLower", "(I)V", 1) javabridge.call( self.jobject, "setRunUpper", "(I)V", self.runs) # setup result producer rproducer, prop_path = self.configure_resultproducer() javabridge.call( self.jobject, "setResultProducer", "(Lweka/experiment/ResultProducer;)V", rproducer) javabridge.call( self.jobject, "setPropertyPath", "([Lweka/experiment/PropertyNode;)V", prop_path) # classifiers classifiers = javabridge.get_env().make_object_array( len(self.classifiers), javabridge.get_env().find_class("weka/classifiers/Classifier")) for i, classifier in enumerate(self.classifiers): if type(classifier) is Classifier: javabridge.get_env().set_object_array_element( classifiers, i, classifier.jobject) else: javabridge.get_env().set_object_array_element( classifiers, i, utils.from_commandline(classifier).jobject) javabridge.call( self.jobject, "setPropertyArray", "(Ljava/lang/Object;)V", classifiers) # datasets datasets = javabridge.make_instance("javax/swing/DefaultListModel", "()V") for dataset in self.datasets: f = javabridge.make_instance("java/io/File", "(Ljava/lang/String;)V", dataset) javabridge.call(datasets, "addElement", "(Ljava/lang/Object;)V", f) javabridge.call( self.jobject, "setDatasets", "(Ljavax/swing/DefaultListModel;)V", datasets) # output file if str(self.result).lower().endswith(".arff"): rlistener = javabridge.make_instance("weka/experiment/InstancesResultListener", "()V") elif str(self.result).lower().endswith(".csv"): rlistener = javabridge.make_instance("weka/experiment/CSVResultListener", "()V") else: raise Exception("Unhandled output format for results: " + self.result) rfile = javabridge.make_instance("java/io/File", "(Ljava/lang/String;)V", self.result) javabridge.call( rlistener, "setOutputFile", "(Ljava/io/File;)V", rfile) javabridge.call( self.jobject, "setResultListener", "(Lweka/experiment/ResultListener;)V", rlistener) def run(self): """ Executes the experiment. """ logger.info("Initializing...") javabridge.call(self.jobject, "initialize", "()V") logger.info("Running...") javabridge.call(self.jobject, "runExperiment", "()V") logger.info("Finished...") javabridge.call(self.jobject, "postProcess", "()V") def experiment(self): """ Returns the internal experiment, if set up, otherwise None. :return: the internal experiment :rtype: Experiment """ if self.jobject is None: return None else: return Experiment(jobject=self.jobject) @classmethod def load(cls, filename): """ Loads the experiment from disk. :param filename: the filename of the experiment to load :type filename: str :return: the experiment :rtype: Experiment """ jobject = javabridge.static_call( "weka/experiment/Experiment", "read", "(Ljava/lang/String;)Lweka/experiment/Experiment;", filename) return Experiment(jobject=jobject) @classmethod def save(cls, filename, experiment): """ Saves the experiment to disk. :param filename: the filename to save the experiment to :type filename: str :param experiment: the Experiment to save :type experiment: Experiment """ javabridge.static_call( "weka/experiment/Experiment", "write", "(Ljava/lang/String;Lweka/experiment/Experiment;)V", filename, experiment.jobject) class SimpleCrossValidationExperiment(SimpleExperiment): """ Performs a simple cross-validation experiment. Can output the results either in ARFF or CSV. """ def __init__(self, datasets, classifiers, classification=True, runs=10, folds=10, result=None): """ Initializes the experiment. :param datasets: the filenames of datasets to use in the experiment :type datasets: list :param classifiers: the Classifier objects to use in the experiment :type classifiers: list :param classification: whether to perform classification :type classification: bool :param runs: the number of runs to perform :type runs: int :param folds: the number folds to use for CV :type folds: int :param result: the filename of the file to store the results in :type result: str """ if runs < 1: raise Exception("Number of runs must be at least 1!") if folds < 2: raise Exception("Number of folds must be at least 2!") if len(datasets) == 0: raise Exception("No datasets provided!") if len(classifiers) == 0: raise Exception("No classifiers provided!") if result is None: raise Exception("No filename for results provided!") super(SimpleCrossValidationExperiment, self).__init__( classification=classification, runs=runs, datasets=datasets, classifiers=classifiers, result=result) self.folds = folds def configure_resultproducer(self): """ Configures and returns the ResultProducer and PropertyPath as tuple. :return: producer and property path :rtype: tuple """ rproducer = javabridge.make_instance("weka/experiment/CrossValidationResultProducer", "()V") javabridge.call(rproducer, "setNumFolds", "(I)V", self.folds) speval, classifier = self.configure_splitevaluator() javabridge.call(rproducer, "setSplitEvaluator", "(Lweka/experiment/SplitEvaluator;)V", speval) prop_path = javabridge.get_env().make_object_array( 2, javabridge.get_env().find_class("weka/experiment/PropertyNode")) cls = javabridge.get_env().find_class("weka/experiment/CrossValidationResultProducer") desc = javabridge.make_instance( "java/beans/PropertyDescriptor", "(Ljava/lang/String;Ljava/lang/Class;)V", "splitEvaluator", cls) node = javabridge.make_instance( "weka/experiment/PropertyNode", "(Ljava/lang/Object;Ljava/beans/PropertyDescriptor;Ljava/lang/Class;)V", speval, desc, cls) javabridge.get_env().set_object_array_element(prop_path, 0, node) cls = javabridge.get_env().get_object_class(speval) desc = javabridge.make_instance( "java/beans/PropertyDescriptor", "(Ljava/lang/String;Ljava/lang/Class;)V", "classifier", cls) node = javabridge.make_instance( "weka/experiment/PropertyNode", "(Ljava/lang/Object;Ljava/beans/PropertyDescriptor;Ljava/lang/Class;)V", javabridge.get_env().get_object_class(speval), desc, cls) javabridge.get_env().set_object_array_element(prop_path, 1, node) return rproducer, prop_path class SimpleRandomSplitExperiment(SimpleExperiment): """ Performs a simple random split experiment. Can output the results either in ARFF or CSV. """ def __init__(self, datasets, classifiers, classification=True, runs=10, percentage=66.6, preserve_order=False, result=None): """ Initializes the experiment. :param classification: whether to perform classification or regression :type classification: bool :param runs: the number of runs to perform :type runs: int :param percentage: the percentage to use for training :type percentage: float :param preserve_order: whether to preserve the order in the datasets :type preserve_order: bool :param datasets: the filenames of datasets to use in the experiment :type datasets: list :param classifiers: the Classifier objects to use in the experiment :type classifiers: list :param result: the filename of the file to store the results in :type result: str """ if runs < 1: raise Exception("Number of runs must be at least 1!") if percentage <= 0: raise Exception("Percentage for training must be >0!") if percentage >= 100: raise Exception("Percentage for training must be <100!") if len(datasets) == 0: raise Exception("No datasets provided!") if len(classifiers) == 0: raise Exception("No classifiers provided!") if result is None: raise Exception("No filename for results provided!") super(SimpleRandomSplitExperiment, self).__init__( classification=classification, runs=runs, datasets=datasets, classifiers=classifiers, result=result) self.percentage = percentage self.preserve_order = preserve_order def configure_resultproducer(self): """ Configures and returns the ResultProducer and PropertyPath as tuple. :return: producer and property path :rtype: tuple """ rproducer = javabridge.make_instance("weka/experiment/RandomSplitResultProducer", "()V") javabridge.call(rproducer, "setRandomizeData", "(Z)V", not self.preserve_order) javabridge.call(rproducer, "setTrainPercent", "(D)V", self.percentage) speval, classifier = self.configure_splitevaluator() javabridge.call(rproducer, "setSplitEvaluator", "(Lweka/experiment/SplitEvaluator;)V", speval) prop_path = javabridge.get_env().make_object_array( 2, javabridge.get_env().find_class("weka/experiment/PropertyNode")) cls = javabridge.get_env().find_class("weka/experiment/RandomSplitResultProducer") desc = javabridge.make_instance( "java/beans/PropertyDescriptor", "(Ljava/lang/String;Ljava/lang/Class;)V", "splitEvaluator", cls) node = javabridge.make_instance( "weka/experiment/PropertyNode", "(Ljava/lang/Object;Ljava/beans/PropertyDescriptor;Ljava/lang/Class;)V", speval, desc, cls) javabridge.get_env().set_object_array_element(prop_path, 0, node) cls = javabridge.get_env().get_object_class(speval) desc = javabridge.make_instance( "java/beans/PropertyDescriptor", "(Ljava/lang/String;Ljava/lang/Class;)V", "classifier", cls) node = javabridge.make_instance( "weka/experiment/PropertyNode", "(Ljava/lang/Object;Ljava/beans/PropertyDescriptor;Ljava/lang/Class;)V", javabridge.get_env().get_object_class(speval), desc, cls) javabridge.get_env().set_object_array_element(prop_path, 1, node) return rproducer, prop_path class ResultMatrix(OptionHandler): """ For generating results from an Experiment run. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified ResultMatrix using either the classname or the supplied JB_Object. :param classname: the classname of the ResultMatrix :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to use :type options: list """ if jobject is None: jobject = ResultMatrix.new_instance(classname) self.enforce_type(jobject, "weka.experiment.ResultMatrix") super(ResultMatrix, self).__init__(jobject=jobject, options=options) def to_string_matrix(self): """ Returns the matrix as a string. :return: the generated output :rtype: str """ return javabridge.call(self.jobject, "toStringMatrix", "()V") def to_string_key(self): """ Returns a key for all the col names, for better readability if the names got cut off. :return: the key :rtype: str """ return javabridge.call(self.jobject, "toStringKey", "()V") def to_string_header(self): """ Returns the header of the matrix as a string. :return: the header :rtype: str """ return javabridge.call(self.jobject, "toStringHeader", "()V") def to_string_summary(self): """ returns the summary as string. :return: the summary :rtype: str """ return javabridge.call(self.jobject, "toStringSummary", "()V") def to_string_ranking(self): """ Returns the ranking in a string representation. :return: the ranking :rtype: str """ return javabridge.call(self.jobject, "toStringRanking", "()V") class Tester(OptionHandler): """ For generating statistical results from an experiment. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified tester using either the classname or the supplied JB_Object. :param classname: the classname of the tester :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ if jobject is None: jobject = Tester.new_instance(classname) self.enforce_type(jobject, "weka.experiment.Tester") self.columns_determined = False self._dataset_columns = ["Key_Dataset"] self._run_column = "Key_Run" self._fold_column = "Key_Fold" self._result_columns = ["Key_Scheme", "Key_Scheme_options", "Key_Scheme_version_ID"] super(Tester, self).__init__(jobject=jobject, options=options) @property def resultmatrix(self): """ Returns the ResultMatrix instance in use. :return: the matrix in use :rtype: ResultMatrix """ return ResultMatrix( jobject=javabridge.call(self.jobject, "getResultMatrix", "()Lweka/experiment/ResultMatrix;")) @resultmatrix.setter def resultmatrix(self, matrix): """ Sets the ResultMatrix to use. :param matrix: the ResultMatrix instance to use :type matrix: ResultMatrix """ javabridge.call(self.jobject, "setResultMatrix", "(Lweka/experiment/ResultMatrix;)V", matrix.jobject) @property def instances(self): """ Returns the data used in the analysis. :return: the data in use :rtype: Instances """ inst = javabridge.call(self.jobject, "getInstances", "()Lweka/core/Instances;") if inst is None: return None else: return Instances(inst) @instances.setter def instances(self, data): """ Sets the data to use for analysis. :param data: the Instances to analyze :type data: Instances """ javabridge.call(self.jobject, "setInstances", "(Lweka/core/Instances;)V", data.jobject) self.columns_determined = False @property def dataset_columns(self): """ Returns the list of column names that identify uniquely a dataset. :return: the list of attributes names :rtype: list """ return self._dataset_columns @dataset_columns.setter def dataset_columns(self, col_names): """ Sets the list of column names that identify uniquely a dataset. :param col_names: the list of attribute names :type col_names: list """ self._dataset_columns = col_names[:] @property def run_column(self): """ Returns the column name that holds the Run number. :return: the attribute name :rtype: str """ return self._run_column @run_column.setter def run_column(self, col_name): """ Sets the column name that holds the Run number. :param col_name: the attribute name :type col_name: str """ self._run_column = col_name @property def fold_column(self): """ Returns the column name that holds the Fold number. :return: the attribute name :rtype: str """ return self._fold_column @fold_column.setter def fold_column(self, col_name): """ Sets the column name that holds the Fold number. :param col_name: the attribute name :type col_name: str """ self._fold_column = col_name @property def result_columns(self): """ Returns the list of column names that identify uniquely a result (eg classifier + options + ID). :return: the list of attribute names :rtype: list """ return self._result_columns @result_columns.setter def result_columns(self, col_names): """ Sets the list of column names that identify uniquely a result (eg classifier + options + ID). :param col_names: the list of attribute names :type col_names: list """ self._result_columns = col_names[:] def init_columns(self): """ Sets the column indices based on the supplied names if necessary. """ if self.columns_determined: return data = self.instances if data is None: print("No instances set, cannot determine columns!") return # dataset if self.dataset_columns is None: raise Exception("No dataset columns set!") cols = "" for name in self.dataset_columns: att = data.attribute_by_name(name) if att is None: raise Exception("Dataset column not found: " + name) if len(cols) > 0: cols += "," cols += str(att.index + 1) javabridge.call( self.jobject, "setDatasetKeyColumns", "(Lweka/core/Range;)V", Range(ranges=cols).jobject) # run if self.run_column is None: raise Exception("No run columnn set!") att = data.attribute_by_name(self.run_column) if att is None: raise Exception("Run column not found: " + self.run_column) javabridge.call( self.jobject, "setRunColumn", "(I)V", att.index) # fold if not self.fold_column is None: att = data.attribute_by_name(self.fold_column) if att is None: index = -1 else: index = att.index javabridge.call( self.jobject, "setFoldColumn", "(I)V", index) # result if self._result_columns is None: raise Exception("No reset columns set!") cols = "" for name in self._result_columns: att = data.attribute_by_name(name) if att is None: raise Exception("Result column not found: " + name) if len(cols) > 0: cols += "," cols += str(att.index + 1) javabridge.call( self.jobject, "setResultsetKeyColumns", "(Lweka/core/Range;)V", Range(ranges=cols).jobject) self.columns_determined = True def header(self, comparison_column): """ Creates a "header" string describing the current resultsets. :param comparison_column: the index of the column to compare against :type comparison_column: int :return: the header :rtype: str """ self.init_columns() return javabridge.call( self.jobject, "header", "(I)Ljava/lang/String;", comparison_column) def multi_resultset_full(self, base_resultset, comparison_column): """ Creates a comparison table where a base resultset is compared to the other resultsets. :param base_resultset: the 0-based index of the base resultset (eg classifier to compare against) :type base_resultset: int :param comparison_column: the 0-based index of the column to compare against :type comparison_column: int :return: the comparison :rtype: str """ return javabridge.call( self.jobject, "multiResultsetFull", "(II)Ljava/lang/String;", base_resultset, comparison_column) def multi_resultset_ranking(self, comparison_column): """ Creates a ranking. :param comparison_column: the 0-based index of the column to compare against :type comparison_column: int :return: the ranking :rtype: str """ return javabridge.call( self.jobject, "multiResultsetRanking", "(I)Ljava/lang/String;", comparison_column) def multi_resultset_summary(self, comparison_column): """ Carries out a comparison between all resultsets, counting the number of datsets where one resultset outperforms the other. :param comparison_column: the 0-based index of the column to compare against :type comparison_column: int :return: the summary :rtype: str """ return javabridge.call( self.jobject, "multiResultsetSummary", "(I)Ljava/lang/String;", comparison_column) python-weka-wrapper-0.2.2/python/weka/core/0000755017267001726700000000000012452374314022274 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.2.2/python/weka/core/classes.py0000644017267001726700000006253012452314622024305 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # classes.py # Copyright (C) 2014-2015 Fracpete (pythonwekawrapper at gmail dot com) import types import javabridge from javabridge import JWrapper, JClassWrapper from javabridge.jutil import JavaException class JavaObject(object): """ Basic Java object. """ def __init__(self, jobject): """ Initializes the wrapper with the specified Java object. :param jobject: the Java object to wrap :type jobject: JB_Object """ if jobject is None: raise Exception("No Java object supplied!") self.jobject = jobject def __str__(self): """ Just calls the toString() method. :rtype: str """ return javabridge.to_string(self.jobject) def __unicode__(self): """ Just calls the toString() method. :rtype: str """ return javabridge.to_string(self.jobject) @property def classname(self): """ Returns the Java classname in dot-notation. :return: the Java classname :rtype: str """ cls = javabridge.call(self.jobject, "getClass", "()Ljava/lang/Class;") return javabridge.call(cls, "getName", "()Ljava/lang/String;") def set_property(self, path, jobject): """ Attempts to set the value (jobject, a Java object) of the provided (bean) property path. :param path: the property path, e.g., "filter" for a setFilter(...)/getFilter() method pair :type path: str :param jobject: the Java object to set; if instance of JavaObject class, the jobject member is automatically used :type jobject: JB_Object """ # unwrap? if isinstance(jobject, JavaObject): jobject = jobject.jobject javabridge.static_call( "Lweka/core/PropertyPath;", "setValue", "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V", self.jobject, path, jobject) def get_property(self, path): """ Attempts to get the value (jobject, a Java object) of the provided (bean) property path. :param path: the property path, e.g., "filter" for a setFilter(...)/getFilter() method pair :type path: str :return the wrapped Java object :rtype: JavaObject """ return JavaObject(javabridge.static_call( "Lweka/core/PropertyPath;", "getValue", "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;", self.jobject, path)) @property def jclass(self): """ Returns the Java class object of the underlying Java object. :return: the Java class :rtype: JB_Object """ return javabridge.call(self.jobject, "getClass", "()Ljava/lang/Class;") @property def jwrapper(self): """ Returns a JWrapper instance of the encapsulated Java object, giving access to methods using dot notation. http://pythonhosted.org//javabridge/highlevel.html#wrapping-java-objects-using-reflection :return: the wrapper :rtype: JWrapper """ return JWrapper(self.jobject) @property def jclasswrapper(self): """ Returns a JClassWrapper instance of the class for the encapsulated Java object, giving access to the class methods using dot notation. http://pythonhosted.org//javabridge/highlevel.html#wrapping-java-objects-using-reflection :return: the wrapper :rtype: JClassWrapper """ return JClassWrapper(javabridge.call(self.jobject, "getClass", "()Ljava/lang/Class;")) @classmethod def check_type(cls, jobject, intf_or_class, jni_intf_or_class=None): """ Returns whether the object implements the specified interface or is a subclass. E.g.: self._check_type('weka.core.OptionHandler', 'Lweka/core/OptionHandler;') or self._check_type('weka.core.converters.AbstractFileLoader') :param jobject: the Java object to check :type jobject: JB_Object :param intf_or_class: the classname in Java notation (eg "weka.core.DenseInstance;") :type jni_intf_or_class: str :return: whether object implements interface or is subclass :rtype: bool """ if jni_intf_or_class is None: jni_intf_or_class = "L" + intf_or_class.replace(".", "/") + ";" return javabridge.is_instance_of(jobject, jni_intf_or_class) @classmethod def enforce_type(cls, jobject, intf_or_class, jni_intf_or_class=None): """ Raises an exception if the object does not implement the specified interface or is not a subclass. E.g.: self._enforce_type('weka.core.OptionHandler', 'Lweka/core/OptionHandler;') or self._enforce_type('weka.core.converters.AbstractFileLoader') :param jobject: the Java object to check :type jobject: JB_Object :param intf_or_class: the classname in Java notation (eg "weka.core.DenseInstance") :type intf_or_class: str :param jni_intf_or_class: the classname in JNI notation (eg "Lweka/core/DenseInstance;") :type jni_intf_or_class: str """ if not cls.check_type(jobject, intf_or_class, jni_intf_or_class): raise TypeError("Object does not implement or subclass " + intf_or_class + "!") @classmethod def new_instance(cls, classname, jni_classname=None): """ Creates a new object from the given classname using the default constructor, None in case of error. :param classname: the classname in Java notation (eg "weka.core.DenseInstance") :type classname: str :param jni_classname: the classname in JNI notation (eg "Lweka/core/DenseInstance;") :type jni_classname: str :return: the Java object :rtype: JB_Object """ if jni_classname is None: jni_classname = classname.replace(".", "/") try: return javabridge.make_instance(jni_classname, "()V") except JavaException, e: print("Failed to instantiate " + classname + "/" + jni_classname + ": " + str(e)) return None class JavaArrayIterator(object): """ Iterator for elements in a Java array. """ def __init__(self, data): """ :param data: the Java array to iterate over :type data: JavaArray """ self.data = data self.index = 0 self.length = len(data) def __iter__(self): """ Returns itself. """ return self def next(self): """ Returns the next element from the array. :return: the next array element object, wrapped as JavaObject if not null :rtype: JavaObject or None """ if self.index < self.length: index = self.index self.index += 1 return self.data[index] else: raise StopIteration() class JavaArray(JavaObject): """ Convenience wrapper around Java arrays. """ def __init__(self, jobject): """ Initializes the wrapper with the specified Java object. :param jobject: the java array object to wrap :type jobject: JB_Object """ super(JavaArray, self).__init__(jobject) c = self.jclass if not javabridge.call(c, "isArray", "()Z"): raise Exception("Not an array!") def __len__(self): """ Returns the length of the array. :return: the array length :rtype: int """ return javabridge.get_env().get_array_length(self.jobject) def __getitem__(self, key): """ Returns the specified element in the array wrapped in a JavaObject. :param key: the index of the element to retrieve :type key: int :return: the element or None if element is null :rtype; JavaObject """ if not isinstance(key, (int, long)): raise Exception("Key must be an integer!") element = javabridge.static_call( "Ljava/lang/reflect/Array;", "get", "(Ljava/lang/Object;I)Ljava/lang/Object;", self.jobject, key) if element is None: return None return JavaObject(element) def __setitem__(self, key, value): """ Sets the specified element in the array. :param key: the index of the element to set :type key: int :param value: the object to set (JavaObject or JB_Object) """ if isinstance(value, JavaObject): obj = value.jobject else: obj = value if not isinstance(key, (int, long)): raise Exception("Key must be an integer!") javabridge.static_call( "Ljava/lang/reflect/Array;", "set", "(Ljava/lang/Object;ILjava/lang/Object;)V", self.jobject, key, obj) def __delitem__(self, key): """ Not implemented, raises an exception. """ raise Exception("Cannot delete item from array!") def __iter__(self): """ Returns an iterator over the elements. :return: the iterator :rtype: JavaArrayIterator """ return JavaArrayIterator(self) @classmethod def new_instance(cls, classname, length): """ Creates a new array with the given classname and length; initial values are null. :param classname: the classname in Java notation (eg "weka.core.DenseInstance") :type classname: str :param length: the length of the array :type length: int :return: the Java array :rtype: JB_Object """ return javabridge.static_call( "Ljava/lang/reflect/Array;", "newInstance", "(Ljava/lang/Class;I)Ljava/lang/Object;", javabridge.class_for_name(classname=classname), length) class Enum(JavaObject): """ Wrapper for Java enums. """ def __init__(self, jobject=None, enum=None, member=None): """ Initializes the enum class. :param jobject: the Java object to wrap :type jobject: JB_Object :param enum: the enum class to instantiate (dot notation) :type enum: str :param member: the member of the enum class to instantiate :type member: str """ if jobject is None: enumclass = javabridge.class_for_name(classname=enum) enum = enum.replace(".", "/") jobject = javabridge.static_call( "java/lang/Enum", "valueOf", "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;", enumclass, member) super(Enum, self).__init__(jobject) @property def name(self): """ Returns the name of the enum member. :return: the name :rtype: str """ return javabridge.call(self.jobject, "name", "()Ljava/lang/String;") @property def ordinal(self): """ Returns the ordinal of the enum member. :return: the ordinal :rtype: int """ return javabridge.call(self.jobject, "ordinal", "()I") @property def values(self): """ Returns list of all enum members. :return: all enum members :rtype: list """ cls = javabridge.call(self.jobject, "getClass", "()Ljava/lang/Class;") clsname = javabridge.call(cls, "getName", "()Ljava/lang/String;") l = javabridge.static_call(clsname.replace(".", "/"), "values", "()[L" + clsname.replace(".", "/") + ";") l = javabridge.get_env().get_object_array_elements(l) result = [] for item in l: result.append(Enum(jobject=item)) return result class Random(JavaObject): """ Wrapper for the java.util.Random class. """ def __init__(self, seed): """ The seed value. :param seed: the seed value :type seed: int """ super(Random, self).__init__(javabridge.make_instance("Ljava/util/Random;", "(J)V", seed)) def next_int(self, n=None): """ Next random integer. if n is provided, then between 0 and n-1. :param n: the upper limit (minus 1) for the random integer :type n: int :return: the next random integer :rtype: int """ if n is None: return javabridge.call(self.jobject, "nextInt", "()I") else: return javabridge.call(self.jobject, "nextInt", "(I)I", n) def next_double(self): """ Next random double. :return: the next random double :rtype: double """ return javabridge.call(self.jobject, "nextDouble", "()D") class OptionHandler(JavaObject): """ Ancestor for option-handling classes. Classes should implement the weka.core.OptionHandler interface to have any effect. """ def __init__(self, jobject, options=None): """ Initializes the wrapper with the specified Java object. :param jobject: the java object to wrap :type jobject: JB_Object :param options: the options to set :type options: list """ super(OptionHandler, self).__init__(jobject) self.is_optionhandler = OptionHandler.check_type(jobject, "weka.core.OptionHandler") if (not options is None) and (len(options) > 0): self.options = options def global_info(self): """ Returns the globalInfo() result, None if not available. :rtypes: str """ try: return javabridge.call(self.jobject, "globalInfo", "()Ljava/lang/String;") except JavaException: return None @property def options(self): """ Obtains the currently set options as list. :return: the list of options :rtype: list """ if self.is_optionhandler: return types.string_array_to_list(javabridge.call(self.jobject, "getOptions", "()[Ljava/lang/String;")) else: return [] @options.setter def options(self, options): """ Sets the command-line options (as list). :param options: the list of command-line options to set :type options: list """ if self.is_optionhandler: javabridge.call(self.jobject, "setOptions", "([Ljava/lang/String;)V", types.string_list_to_array(options)) def to_commandline(self): """ Generates a commandline string from the JavaObject instance. :return: the commandline string :rtype: str """ return javabridge.static_call( "Lweka/core/Utils;", "toCommandLine", "(Ljava/lang/Object;)Ljava/lang/String;", self.jobject) def __str__(self): """ Calls the toString() method of the java object. :return: the result of the toString() method :rtype: str """ return javabridge.to_string(self.jobject) class SingleIndex(JavaObject): """ Wrapper for a Weka SingleIndex object. """ def __init__(self, jobject=None, index=None): """ Initializes the wrapper with the specified Java object or string index. :param jobject: the java object to wrap :type jobject: JB_Object :param index: the string index to use :type index: str """ if jobject is None: if index is None: jobject = javabridge.make_instance("weka/core/SingleIndex", "()V") else: jobject = javabridge.make_instance("weka/core/SingleIndex", "(Ljava/lang/String;)V", index) else: self.enforce_type(jobject, "weka.core.SingleIndex") super(SingleIndex, self).__init__(jobject) def upper(self, upper): """ Sets the upper limit. :param upper: the upper limit :type upper: int """ javabridge.call(self.jobject, "setUpper", "(I)V", upper) def index(self): """ Returns the integer index. :return: the 0-based integer index :rtype: int """ return javabridge.call(self.jobject, "getIndex", "()I") @property def single_index(self): """ Returns the string index. :return: the 1-based string index :rtype: str """ return javabridge.call(self.jobject, "getSingleIndex", "()Ljava/lang/String;") @single_index.setter def single_index(self, index): """ Sets the string index. :param index: the 1-based string index ::type index: str """ javabridge.call(self.jobject, "setSingleIndex", "(Ljava/lang/String;)V", index) class Range(JavaObject): """ Wrapper for a Weka Range object. """ def __init__(self, jobject=None, ranges=None): """ Initializes the wrapper with the specified Java object or string range. :param jobject: the java object to wrap :type jobject: JB_Object :param ranges: the string range to use :type ranges: str """ if jobject is None: if ranges is None: jobject = javabridge.make_instance("weka/core/Range", "()V") else: jobject = javabridge.make_instance("weka/core/Range", "(Ljava/lang/String;)V", ranges) else: self.enforce_type(jobject, "weka.core.Range") super(Range, self).__init__(jobject) def upper(self, upper): """ Sets the upper limit. :param upper: the upper limit :type upper: int """ javabridge.call(self.jobject, "setUpper", "(I)V", upper) def selection(self): """ Returns the selection list. :return: the list of 0-based integer indices :rtype: list """ return javabridge.get_env().get_int_array_elements(javabridge.call(self.jobject, "getSelection", "()[I")) @property def ranges(self): """ Returns the string range. :return: the string range of 1-based indices :rtype: str """ return javabridge.call(self.jobject, "getRanges", "()Ljava/lang/String;") @ranges.setter def ranges(self, rng): """ Sets the string range. :param rng: the range to set :type rng: str """ javabridge.call(self.jobject, "setRanges", "(Ljava/lang/String;)V", rng) @property def invert(self): """ Returns whether the range is inverted. :return: true if inverted :rtype: bool """ return javabridge.call(self.jobject, "getInvert", "()Z") @invert.setter def invert(self, invert): """ Sets the invert state. :param invert: whether to invert or not :type invert: bool """ javabridge.call(self.jobject, "setInvert", "(Z)V", invert) class Tag(JavaObject): """ Wrapper for the weka.core.Tag class. """ def __init__(self, jobject=None, ident=None, ident_str="", readable="", uppercase=True): """ :param jobject: the java object to wrap :type jobject: JB_Object :param ident: the ID integer associated with the tag :type ident: int :param ident_str: the ID string associated with the tag (case-insensitive) :type ident_str: str :param readable: the text of the tag :type readable: str :param uppercase: whether to uppercase the id string :type uppercase: bool """ if jobject is None: jobject = javabridge.make_instance( "weka/core/Tag", "(ILjava/lang/String;Ljava/lang/String;Z)V", ident, ident_str, readable, uppercase) else: self.enforce_type(jobject, "weka.core.Tag") super(Tag, self).__init__(jobject) @property def ident(self): """ Returns the current integer ID of the tag. :return: the integer ID :rtype: int """ return javabridge.call(self.jobject, "getID", "()I") @ident.setter def ident(self, value): """ Sets the integer ID of the tag. :param value: the new ID :type value: int """ javabridge.call(self.jobject, "setID", "(I)V", value) @property def identstr(self): """ Returns the current ID string. :return: the ID string :rtype: str """ return javabridge.call(self.jobject, "getIDStr", "()Ljava/lang/String;") @identstr.setter def identstr(self, value): """ Sets the ID string. :param value: the new ID string :type value: str """ javabridge.call(self.jobject, "setIDStr", "(Ljava/lang/String;)V", value) @property def readable(self): """ Returns the 'human readable' string. :return: the readable string :rtype: str """ return javabridge.call(self.jobject, "getReadable", "()Ljava/lang/String;") @readable.setter def readable(self, value): """ Sets the 'human readable' string. :param value: the new readable string :type value: str """ javabridge.call(self.jobject, "setReadable", "(Ljava/lang/String;)V", value) class Tags(JavaObject): """ Wrapper for an array of weka.core.Tag objects. """ def __init__(self, jobject=None, tags=None): """ :param jobject: the Java Tag array to wrap. :type jobject: JB_Object :param tags: the list of Tag objects to use :type tags: list """ if not tags is None: jarray = JavaArray(JavaArray.new_instance("weka.core.Tag", len(tags))) for i in range(len(tags)): jarray[i] = tags[i] jobject = jarray.jobject self.enforce_type(jobject, "weka.core.Tag", jni_intf_or_class="[Lweka/core/Tag;") super(Tags, self).__init__(jobject) self.array = JavaArray(self.jobject) def __len__(self): """ Returns the number of Tag objects in the array. :return: the number of tag objects :rtype: int """ return len(self.array) def __getitem__(self, item): """ Returns the specified Tag from the array. :param item: the 0-based index :type item: int :return: the tag :rtype: Tag """ return Tag(self.array[item]) def __setitem__(self, key, value): """ Not implemented. """ raise Exception("Cannot set a Tag!") def __delitem__(self, key): """ Not implemented. """ raise Exception("Cannot delete a Tag!") def __str__(self): """ Just calls the toString() method. :rtype: str """ result = "" for i in xrange(len(self.array)): if i > 0: result += "|" result += str(self.array[i]) return result class SelectedTag(JavaObject): """ Wrapper for the weka.core.SelectedTag class. """ def __init__(self, jobject=None, tag_id=None, tag_text=None, tags=None): """ Initializes the wrapper with the specified Java object or tags and either tag_id or tag_text. :param jobject: the java object to wrap :type jobject: JB_Object :param tag_id: the integer associated with the tag :type tag_id: int :param tag_text: the text associated with the tag :type tag_text: str :param tags: list of Tag objects or Tags wrapper object :type tags: list or Tags """ if isinstance(tags, Tags): tobj = tags.jobject else: tobj = tags if jobject is None: if tag_id is None: jobject = javabridge.make_instance( "weka/core/SelectedTag", "(Ljava/lang/String;[Lweka/core/Tag;)V", tag_text, tobj) else: jobject = javabridge.make_instance( "weka/core/SelectedTag", "(I[Lweka/core/Tag;)V", tag_id, tobj) else: self.enforce_type(jobject, "weka.core.SelectedTag") super(SelectedTag, self).__init__(jobject) @property def selected(self): """ Returns the selected tag. :return: the tag :rtype: Tag """ return Tag(javabridge.call(self.jobject, "getSelectedTag", "()Lweka/core/Tag;")) @property def tags(self): """ Returns the associated tags. :return: the list of Tag objects :rtype: list """ result = [] a = javabridge.call(self.jobject, "getTags", "()Lweka/core/Tag;]") length = javabridge.get_env().get_array_length(a) wrapped = javabridge.get_env().get_object_array_elements(a) for i in xrange(length): result.append(Tag(javabridge.get_env().get_string(wrapped[i]))) return result python-weka-wrapper-0.2.2/python/weka/core/utils.py0000644017267001726700000001022412452314622024001 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # utils.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging import inspect import weka.core.types as arrays from weka.core.classes import OptionHandler # logging setup logger = logging.getLogger(__name__) def get_class(classname): """ Returns the class object associated with the dot-notation classname. Taken from here: http://stackoverflow.com/a/452981 :param classname: the classname :type classname: str :return: the class object :rtype: object """ parts = classname.split('.') module = ".".join(parts[:-1]) m = __import__(module) for comp in parts[1:]: m = getattr(m, comp) return m def get_jclass(classname): """ Returns the Java class object associated with the dot-notation classname. :param classname: the classname :type classname: str :return: the class object :rtype: JB_Object """ return javabridge.class_for_name(classname=classname) def get_classname(obj): """ Returns the classname of the JB_Object, Python class or object. :param obj: the java object or Python class/object to get the classname for :type obj: object :return: the classname :rtype: str """ if isinstance(obj, javabridge.JB_Object): cls = javabridge.call(obj, "getClass", "()Ljava/lang/Class;") return javabridge.call(cls, "getName", "()Ljava/lang/String;") elif inspect.isclass(obj): return obj.__module__ + "." + obj.__name__ else: return get_classname(obj.__class__) def split_options(cmdline): """ Splits the commandline into a list of options. :param cmdline: the commandline string to split into individual options :type cmdline: str :return: the split list of commandline options :rtype: list """ return arrays.string_array_to_list( javabridge.static_call( "Lweka/core/Utils;", "splitOptions", "(Ljava/lang/String;)[Ljava/lang/String;", cmdline)) def join_options(options): """ Turns the list of options back into a single commandline string. :param options: the list of options to process :type options: list :return: the combined options :rtype: str """ return javabridge.static_call( "Lweka/core/Utils;", "joinOptions", "([Ljava/lang/String;)Ljava/lang/String;", options) def to_commandline(optionhandler): """ Generates a commandline string from the OptionHandler instance. :param optionhandler: the OptionHandler instance to turn into a commandline :type optionhandler: OptionHandler :return: the commandline string :rtype: str """ return javabridge.static_call( "Lweka/core/Utils;", "toCommandLine", "(Ljava/lang/Object;)Ljava/lang/String;", optionhandler.jobject) def from_commandline(cmdline, classname=None): """ Creates an OptionHandler based on the provided commandline string. :param cmdline: the commandline string to use :type cmdline: str :param classname: the classname of the wrapper to return other than OptionHandler (in dot-notation) :type classname: str :return: the generated option handler instance :rtype: object """ params = split_options(cmdline) cls = params[0] params = params[1:] handler = OptionHandler(jobject=javabridge.make_instance(cls.replace(".", "/"), "()V"), options=params) if classname is None: return handler else: c = get_class(classname) return c(jobject=handler.jobject) python-weka-wrapper-0.2.2/python/weka/core/dataset.py0000644017267001726700000011673312452373532024307 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # dataset.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging import numpy from weka.core.classes import JavaObject import weka.core.types as types # logging setup logger = logging.getLogger(__name__) class Instances(JavaObject): """ Wrapper class for weka.core.Instances. """ def __init__(self, jobject): """ Initializes the weka.core.Instances wrapper. :param jobject: the weka.core.Instances object to wrap :type jobject: JB_Object """ self.enforce_type(jobject, "weka.core.Instances") super(Instances, self).__init__(jobject) self.__attribute = javabridge.make_call(self.jobject, "attribute", "(I)Lweka/core/Attribute;") self.__attribute_by_name = javabridge.make_call(self.jobject, "attribute", "(Ljava/lang/String;)Lweka/core/Attribute;") self.__num_attributes = javabridge.make_call(self.jobject, "numAttributes", "()I") self.__num_instances = javabridge.make_call(self.jobject, "numInstances", "()I") self.__get_class_index = javabridge.make_call(self.jobject, "classIndex", "()I") self.__set_class_index = javabridge.make_call(self.jobject, "setClassIndex", "(I)V") self.__class_attribute = javabridge.make_call(self.jobject, "classAttribute", "()Lweka/core/Attribute;") self.__get_instance = javabridge.make_call(self.jobject, "instance", "(I)Lweka/core/Instance;") self.__set_instance = javabridge.make_call(self.jobject, "set", "(ILweka/core/Instance;)Lweka/core/Instance;") self.__append_instance = javabridge.make_call(self.jobject, "add", "(Lweka/core/Instance;)Z") self.__insert_instance = javabridge.make_call(self.jobject, "add", "(ILweka/core/Instance;)V") def __iter__(self): """ Allows iterating over the rows. :return: the iterator :rtype: InstanceIterator """ return InstanceIterator(self) @property def relationname(self): """ Returns the name of the dataset. :return: the name :rtype: str """ return javabridge.call(self.jobject, "relationName", "()Ljava/lang/String;") @property def num_attributes(self): """ Returns the number of attributes. :return: the number of attributes :rtype: int """ return self.__num_attributes() def attributes(self): """ Returns an iterator over the attributes. """ return AttributeIterator(self) def attribute(self, index): """ Returns the specified attribute. :param index: the 0-based index of the attribute :type index: int :return: the attribute :rtype: Attribute """ return Attribute(self.__attribute(index)) def attribute_by_name(self, name): """ Returns the specified attribute, None if not found. :param name: the name of the attribute :type name: str :return: the attribute or None :rtype: Attribute """ att = self.__attribute_by_name(javabridge.get_env().new_string(name)) if att is None: return None else: return Attribute(att) def attribute_stats(self, index): """ Returns the specified attribute statistics. :param index: the 0-based index of the attribute :type index: int :return: the attribute statistics :rtype: AttributeStats """ return AttributeStats(javabridge.call(self.jobject, "attributeStats", "(I)Lweka/core/AttributeStats;", index)) def values(self, index): """ Returns the internal values of this attribute from all the instance objects. :return: the values as numpy array :rtype: list """ values = [] for i in xrange(self.num_instances): inst = self.get_instance(i) values.append(inst.get_value(index)) return numpy.array(values) @property def num_instances(self): """ Returns the number of instances. :return: the number of instances :rtype: int """ return self.__num_instances() @property def class_attribute(self): """ Returns the currently set class attribute. :return: the class attribute :rtype: Attribute """ return Attribute(self.__class_attribute()) @property def class_index(self): """ Returns the currently set class index (0-based). :return: the class index, -1 if not set :rtype: int """ return self.__get_class_index() @class_index.setter def class_index(self, index): """ Sets the class index (0-based). :param index: the new index, use -1 to unset :type index: int """ self.__set_class_index(index) def has_class(self): """ Returns whether a class attribute is set(convenience method). :return: whether a class attribute is currently set :rtype: bool """ return self.class_index != -1 def no_class(self): """ Unsets the class attribute (convenience method). """ self.class_index = -1 def class_is_first(self): """ Sets the first attribute as class attribute (convenience method). """ self.class_index = 0 def class_is_last(self): """ Sets the last attribute as class attribute (convenience method). """ self.class_index = self.num_attributes - 1 def get_instance(self, index): """ Returns the Instance object at the specified location. :param index: the 0-based index of the instance :type index: int :return: the instance :rtype: Instance """ return Instance(self.__get_instance(index)) def add_instance(self, inst, index=None): """ Adds the specified instance to the dataset. :param inst: the Instance to add :type inst: Instance :param index: the 0-based index where to add the Instance :type index: int """ if index is None: self.__append_instance(inst.jobject) else: self.__insert_instance(index, inst.jobject) def set_instance(self, index, inst): """ Sets the Instance at the specified location in the dataset. :param index: the 0-based index of the instance to replace :type index; int :param inst: the Instance to set :type inst: Instance :return: the instance :rtype: Instance """ return Instance( self.__set_instance(index, inst.jobject)) def delete(self, index=None): """ Removes either the specified Instance or all Instance objects. :param index: the 0-based index of the instance to remove :type index: int """ if index is None: javabridge.call(self.jobject, "delete", "()V") else: javabridge.call(self.jobject, "delete", "(I)V", index) def delete_attribute(self, index): """ Deletes an attribute at the given position. :param index: the 0-based index of the attribute to remove :type index: int """ javabridge.call(self.jobject, "deleteAttributeAt", "(I)V", index) def delete_first_attribute(self): """ Deletes the first attribute. """ self.delete_attribute(0) def delete_last_attribute(self): """ Deletes the last attribute. """ self.delete_attribute(self.num_attributes - 1) def delete_attribute_type(self, typ): """ Deletes all attributes of the given type in the dataset. :param typ: the attribute type to remove, see weka.core.Attribute Javadoc :type typ: int """ javabridge.call(self.jobject, "deleteAttributeType", "(I)V", typ) def delete_with_missing(self, index): """ Deletes all rows that have a missing value at the specified attribute index. :param index: the attribute index to check for missing attributes :type index: int """ javabridge.call(self.jobject, "deleteWithMissing", "(I)V", index) def compactify(self): """ Compactifies the set of instances. """ javabridge.call(self.jobject, "compactify", "()V") def sort(self, index): """ Sorts the dataset using the specified attribute index. :param index: the index of the attribute :type index: int """ javabridge.call(self.jobject, "sort", "(I)V", index) def randomize(self, random): """ Randomizes the dataset using the random number generator. :param random: the random number generator to use :type random: Random """ javabridge.call(self.jobject, "randomize", "(Ljava/util/Random;)V", random.jobject) def stratify(self, folds): """ Stratifies the data after randomization for nominal class attributes. :param folds: the number of folds to perform the stratification for :type folds: int """ javabridge.call(self.jobject, "stratify", "(I)V", folds) def train_cv(self, num_folds, fold, random=None): """ Generates a training fold for cross-validation. :param num_folds: the number of folds of cross-validation, eg 10 :type num_folds: int :param fold: the current fold (0-based) :type fold: int :param random: the random number generator :type random: Random :return: the training fold :rtype: Instances """ if random is None: return Instances( javabridge.call(self.jobject, "trainCV", "(II)Lweka/core/Instances;", num_folds, fold)) else: return Instances( javabridge.call(self.jobject, "trainCV", "(IILjava/util/Random;)Lweka/core/Instances;", num_folds, fold, random.jobject)) def test_cv(self, num_folds, fold): """ Generates a test fold for cross-validation. :param num_folds: the number of folds of cross-validation, eg 10 :type num_folds: int :param fold: the current fold (0-based) :type fold: int :return: the training fold :rtype: Instances """ return Instances( javabridge.call(self.jobject, "testCV", "(II)Lweka/core/Instances;", num_folds, fold)) def equal_headers(self, inst): """ Compares this dataset against the given one in terms of attributes. :param inst: the dataset to compare against :type inst: Instances :return: None if the same, otherwise an error message :rtype: str """ return javabridge.call( self.jobject, "equalHeadersMsg", "(Lweka/core/Instances;)Ljava/lang/String;", inst.jobject) @classmethod def copy_instances(cls, dataset, from_row=None, num_rows=None): """ Creates a copy of the Instances. If either from_row or num_rows are None, then all of the data is being copied. :param dataset: the original dataset :type dataset: Instances :param from_row: the 0-based start index of the rows to copy :type from_row: int :param num_rows: the number of rows to copy :type num_rows: int :return: the copy of the data :rtype: Instances """ if from_row is None or num_rows is None: return Instances( javabridge.make_instance( "weka/core/Instances", "(Lweka/core/Instances;)V", dataset.jobject)) else: dataset = cls.copy_instances(dataset) return Instances( javabridge.make_instance( "weka/core/Instances", "(Lweka/core/Instances;II)V", dataset.jobject, from_row, num_rows)) @classmethod def template_instances(cls, dataset, capacity=0): """ Uses the Instances as template to create an empty dataset. :param dataset: the original dataset :type dataset: Instances :param capacity: how many data rows to reserve initially (see compactify) :type capacity: int :return: the empty dataset :rtype: Instances """ return Instances( javabridge.make_instance( "weka/core/Instances", "(Lweka/core/Instances;I)V", dataset.jobject, capacity)) @classmethod def create_instances(cls, name, atts, capacity): """ Creates a new Instances. :param name: the relation name :type name: str :param atts: the list of attributes to use for the dataset :type atts: list of Attribute :param capacity: how many data rows to reserve initially (see compactify) :type capacity: int :return: the dataset :rtype: Instances """ attributes = [] for att in atts: attributes.append(att.jobject) return Instances( javabridge.make_instance( "weka/core/Instances", "(Ljava/lang/String;Ljava/util/ArrayList;I)V", name, javabridge.make_list(attributes), capacity)) @classmethod def merge_instances(cls, inst1, inst2): """ Merges the two datasets (side-by-side). :param inst1: the first dataset :type inst1: Instances or str :param inst2: the first dataset :type inst2: Instances :return: the combined dataset :rtype: Instances """ return Instances(javabridge.static_call( "weka/core/Instances", "mergeInstances", "(Lweka/core/Instances;Lweka/core/Instances;)Lweka/core/Instances;", inst1.jobject, inst2.jobject)) @classmethod def append_instances(cls, inst1, inst2): """ Merges the two datasets (one-after-the-other). Throws an exception if the datasets aren't compatible. :param inst1: the first dataset :type inst1: Instances :param inst2: the first dataset :type inst2: Instances :return: the combined dataset :rtype: Instances """ msg = inst1.equal_headers(inst2) if not msg is None: raise Exception("Cannot appent instances: " + msg) result = cls.copy_instances(inst1) for i in xrange(inst2.num_instances): result.add_instance(inst2.get_instance(i)) return result @classmethod def summary(cls, inst): """ Generates a summary of the dataset. :param inst: the dataset :type inst: Instances :return: the summary :rtype: str """ return javabridge.call(inst.jobject, "toSummaryString", "()Ljava/lang/String;") class Instance(JavaObject): """ Wrapper class for weka.core.Instance. """ def __init__(self, jobject): """ Initializes the weka.core.Instance wrapper. :param jobject: the weka.core.Instance object to initialize with :type jobject: JB_Object """ self.enforce_type(jobject, "weka.core.Instance") super(Instance, self).__init__(jobject) self.__set_value = javabridge.make_call(self.jobject, "setValue", "(ID)V") self.__get_value = javabridge.make_call(self.jobject, "value", "(I)D") self.__set_string_value = javabridge.make_call(self.jobject, "setValue", "(ILjava/lang/String;)V") self.__get_string_value = javabridge.make_call(self.jobject, "stringValue", "(I)Ljava/lang/String;") self.__set_weight = javabridge.make_call(self.jobject, "setWeight", "(D)V") self.__get_weight = javabridge.make_call(self.jobject, "weight", "()D") self.__is_missing = javabridge.make_call(self.jobject, "isMissing", "(I)Z") self.__class_index = javabridge.make_call(self.jobject, "classIndex", "()I") def __iter__(self): """ Returns an iterator over the values. :return: a value iterator :rtype: InstanceValueIterator """ return InstanceValueIterator(self) @property def dataset(self): """ Returns the dataset that this instance belongs to. :return: the dataset or None if no dataset set :rtype: Instances """ dataset = javabridge.call(self.jobject, "dataset", "()Lweka/core/Instances;") if dataset is None: return None else: return Instances(dataset) @dataset.setter def dataset(self, dataset): """ Sets the dataset that this instance belongs to (for attribute information). :param dataset: the dataset this instance belongs to. :type dataset: Instances """ javabridge.call(self.jobject, "setDataset", "(Lweka/core/Instances;)V", dataset.jobject) @property def num_attributes(self): """ Returns the number of attributes. :return: the numer of attributes :rtype: int """ return javabridge.call(self.jobject, "numAttributes", "()I") @property def num_classes(self): """ Returns the number of class labels. :return: the numer of class labels :rtype: int """ return javabridge.call(self.jobject, "numClasses", "()I") @property def class_attribute(self): """ Returns the currently set class attribute. :return: the class attribute :rtype: Attribute """ return Attribute(javabridge.call(self.jobject, "classAttribute", "()Lweka/core/Attribute;")) @property def class_index(self): """ Returns the currently set class index. :return: the class index, -1 if not set :rtype: int """ return self.__class_index() def set_value(self, index, value): """ Sets the internal value at the specified position (0-based). :param index: the 0-based index of the attribute :type index: int :param value: the internal float value to set :type value: float """ self.__set_value(index, value) def get_value(self, index): """ Returns the internal value at the specified position (0-based). :param index: the 0-based index of the inernal value :type index: int :return: the internal value :rtype: float """ return self.__get_value(index) def set_string_value(self, index, s): """ Sets the string value at the specified position (0-based). :param index: the 0-based index of the inernal value :type index: int :param s: the string value :type s: str """ return self.__set_string_value(index, javabridge.get_env().new_string(s)) def get_string_value(self, index): """ Returns the string value at the specified position (0-based). :param index: the 0-based index of the inernal value :type index: int :return: the string value :rtype: str """ return javabridge.get_env().get_string(self.__get_string_value(index)) def get_relational_value(self, index): """ Returns the relational value at the specified position (0-based). :param index: the 0-based index of the inernal value :type index: int :return: the relational value :rtype: Instances """ return Instances(javabridge.call(self.jobject, "relationalValue", "(I)Lweka/core/Instances;", index)) def set_missing(self, index): """ Sets the attribute at the specified index to missing. :param index: the 0-based index of the attribute :type index: int """ javabridge.call(self.jobject, "setMissing", "(I)V", index) def is_missing(self, index): """ Returns whether the attribute at the specified index is missing. :param index: the 0-based index of the attribute :type index: int :return: whether the value is missing :rtype: bool """ return self.__is_missing(index) def has_missing(self): """ Returns whether at least one attribute has a missing value. :return: whether at least one value is missing :rtype: bool """ return javabridge.call(self.jobject, "hasMissingValue", "()Z") @property def weight(self): """ Returns the currently set weight. :return: the weight :rtype: float """ return self.__get_weight() @weight.setter def weight(self, weight): """ Sets the weight. :param weight: the weight to set :type weight: float """ self.__set_weight(weight) @property def values(self): """ Returns the internal values of this instance. :return: the values as numpy array :rtype: ndarray """ return javabridge.get_env().get_double_array_elements(javabridge.call(self.jobject, "toDoubleArray", "()[D")) @classmethod def create_instance(cls, values, classname="weka.core.DenseInstance", weight=1.0): """ Creates a new instance. :param values: the float values (internal format) to use (numpy array) :type values: ndarray or list :param classname: the classname of the instance (eg weka.core.DenseInstance). :type classname: str :param weight: the weight of the instance :type weight: float """ jni_classname = classname.replace(".", "/") if type(values) is list: values = numpy.array(values) return Instance( javabridge.make_instance(jni_classname, "(D[D)V", weight, javabridge.get_env().make_double_array(values))) class Attribute(JavaObject): """ Wrapper class for weka.core.Attribute. """ def __init__(self, jobject): """ Initializes the weka.core.Attribute wrapper. """ self.enforce_type(jobject, "weka.core.Attribute") super(Attribute, self).__init__(jobject) @property def name(self): """ Returns the name of the attribute. :return: the name :rtype: str """ return javabridge.call(self.jobject, "name", "()Ljava/lang/String;") @property def index(self): """ Returns the index of this attribute. :return: the index :rtype: int """ return javabridge.call(self.jobject, "index", "()I") @property def weight(self): """ Returns the weight of the attribute. :return: the weight :rtype: float """ return javabridge.call(self.jobject, "weight", "()D") @weight.setter def weight(self, weight): """ Sets the weight of the attribute. :param weight: the weight of the attribute :type weight: float """ javabridge.call(self.jobject, "setWeight", "(D)V", weight) def index_of(self, label): """ Returns the index of the label in this attribute. :param label: the string label to get the index for :type label: str :return: the 0-based index :rtype: int """ return javabridge.call(self.jobject, "indexOf", "(Ljava/lang/String;)I", label) def value(self, index): """ Returns the label for the index. :param index: the 0-based index of the label to return :type index: int :return: the label :rtype: str """ return javabridge.call(self.jobject, "value", "(I)Ljava/lang/String;", index) @property def num_values(self): """ Returns the number of labels. :return: the number of labels :rtype: int """ return javabridge.call(self.jobject, "numValues", "()I") @property def values(self): """ Returns the labels, strings or relation-values. :return: all the values, None if not NOMINAL, STRING, or RELATION :rtype: list """ enm = javabridge.call(self.jobject, "enumerateValues", "()Ljava/util/Enumeration;") if enm is None: return None else: return types.enumeration_to_list(enm) @property def ordering(self): """ Returns the ordering of the attribute. :return: the ordering (ORDERING_SYMBOLIC, ORDERING_ORDERED, ORDERING_MODULO) :rtype: int """ return javabridge.call(self.jobject, "ordering", "()I") @property def type(self): """ Returns the type of the attribute. See weka.core.Attribute Javadoc. :return: the type :rtype: int """ return javabridge.call(self.jobject, "type", "()I") def type_str(self, short=False): """ Returns the type of the attribute as string. :return: the type :rtype: str """ if short: return javabridge.static_call( "weka/core/Attribute", "typeToStringShort", "(Lweka/core/Attribute;)Ljava/lang/String;", self.jobject) else: return javabridge.static_call( "weka/core/Attribute", "typeToString", "(Lweka/core/Attribute;)Ljava/lang/String;", self.jobject) @property def is_averagable(self): """ Returns whether the attribute is averagable. :return: whether averagable :rtype: bool """ return javabridge.call(self.jobject, "isAveragable", "()Z") @property def is_date(self): """ Returns whether the attribute is a date one. :return: whether date attribute :rtype: bool """ return javabridge.call(self.jobject, "isDate", "()Z") @property def is_nominal(self): """ Returns whether the attribute is a nominal one. :return: whether nominal attribute :rtype: bool """ return javabridge.call(self.jobject, "isNominal", "()Z") @property def is_numeric(self): """ Returns whether the attribute is a numeric one (date or numeric). :return: whether numeric attribute :rtype: bool """ return javabridge.call(self.jobject, "isNumeric", "()Z") @property def is_relation_valued(self): """ Returns whether the attribute is a relation valued one. :return: whether relation valued attribute :rtype: bool """ return javabridge.call(self.jobject, "isRelationValued", "()Z") @property def is_string(self): """ Returns whether the attribute is a string attribute. :return: whether string attribute :rtype: bool """ return javabridge.call(self.jobject, "isString", "()Z") @property def date_format(self): """ Returns the format of this data attribute. See java.text.SimpleDateFormat Javadoc. :return: the format string :rtype: str """ return javabridge.call(self.jobject, "getDateFormat", "()Ljava/lang/String;") @property def lower_numeric_bound(self): """ Returns the lower numeric bound of the numeric attribute. :return: the lower bound :rtype: float """ return javabridge.call(self.jobject, "getLowerNumericBound", "()D") @property def upper_numeric_bound(self): """ Returns the upper numeric bound of the numeric attribute. :return: the upper bound :rtype: float """ return javabridge.call(self.jobject, "getUpperNumericBound", "()D") def is_in_range(self, value): """ Checks whether the value is within the bounds of the numeric attribute. :param value: the numeric value to check :type value: float :return: whether between lower and upper bound :rtype: bool """ return javabridge.call(self.jobject, "isInRange", "(D)Z", value) def add_string_value(self, s): """ Adds the string value, returns the index. :param s: the string to add :type s: str :return: the index :rtype: int """ return javabridge.call(self.jobject, "addStringValue", "(S)I", s) def add_relation(self, instances): """ Adds the relation value, returns the index. :param instances: the Instances object to add :type instances: Instances :return: the index :rtype: int """ return javabridge.call(self.jobject, "addRelation", "(Lweka/core/Instances;)I", instances.jobject) def parse_date(self, s): """ Parses the date string and returns the internal format value. :param s: the date string :type s: str :return: the internal format :rtype: float """ return javabridge.call(self.jobject, "parseDate", "(Ljava/lang/String;)D", s) def equals(self, att): """ Checks whether this attributes is the same as the provided one. :param att: the Attribute to check against :type att: Attribute :return: whether the same :rtype: bool """ return javabridge.call(self.jobject, "equals", "(Lweka/core/Attribute;)Z", att.jobject) def equals_msg(self, att): """ Checks whether this attributes is the same as the provided one. Returns None if the same, otherwise error message. :param att: the Attribute to check against :type att: Attribute :return: None if the same, otherwise error message :rtype: str """ return javabridge.call(self.jobject, "equalsMsg", "(Lweka/core/Attribute;)Ljava/lang/String;", att.jobject) def copy(self, name=None): """ Creates a copy of this attribute. :param name: the new name, uses the old one if None :type name: str :return: the copy of the attribute :rtype: Attribute """ if name is None: return Attribute( javabridge.call(self.jobject, "copy", "()Ljava/lang/Object;")) else: return Attribute( javabridge.call(self.jobject, "copy", "(Ljava/lang/String;)Lweka/core/Attribute;", name)) @classmethod def create_numeric(cls, name): """ Creates a numeric attribute. :param name: the name of the attribute :type name: str """ return Attribute( javabridge.make_instance( "weka/core/Attribute", "(Ljava/lang/String;)V", name)) @classmethod def create_date(cls, name, formt="yyyy-MM-dd'T'HH:mm:ss"): """ Creates a date attribute. :param name: the name of the attribute :type name: str :param formt: the date format, see Javadoc for java.text.SimpleDateFormat :type formt: str """ return Attribute( javabridge.make_instance( "weka/core/Attribute", "(Ljava/lang/String;Ljava/lang/String;)V", name, formt)) @classmethod def create_nominal(cls, name, labels): """ Creates a nominal attribute. :param name: the name of the attribute :type name: str :param labels: the list of string labels to use :type labels: list """ return Attribute( javabridge.make_instance( "weka/core/Attribute", "(Ljava/lang/String;Ljava/util/List;)V", name, javabridge.make_list(labels))) @classmethod def create_string(cls, name): """ Creates a string attribute. :param name: the name of the attribute :type name: str """ return Attribute( javabridge.make_instance( "weka/core/Attribute", "(Ljava/lang/String;Ljava/util/List;)V", name, None)) class AttributeStats(JavaObject): """ Container for attribute statistics. """ def __init__(self, jobject): """ Initializes the container. :param jobject: The Java object to wrap :type jobject: JB_Object """ self.enforce_type(jobject, "weka.core.AttributeStats") super(AttributeStats, self).__init__(jobject) @property def distinct_count(self): """ The number of distinct values. :return: The number of distinct values :rtype: int """ return javabridge.get_field(self.jobject, "distinctCount", "I") @property def int_count(self): """ The number of int-like values. :return: The number of int-like values :rtype: int """ return javabridge.get_field(self.jobject, "intCount", "I") @property def missing_count(self): """ The number of missing values. :return: The number of missing values :rtype: int """ return javabridge.get_field(self.jobject, "missingCount", "I") @property def nominal_counts(self): """ Counts of each nominal value. :return: Counts of each nominal value :rtype: ndarray """ return javabridge.get_env().get_int_array_elements( javabridge.get_field(self.jobject, "nominalCounts", "[I")) @property def nominal_weights(self): """ Weight mass for each nominal value. :return: Weight mass for each nominal value :rtype: ndarray """ return javabridge.get_env().get_double_array_elements( javabridge.get_field(self.jobject, "nominalWeights", "[D")) @property def numeric_stats(self): """ Stats on numeric value distributions. :return: Stats on numeric value distributions :rtype: NumericStats """ return Stats(javabridge.get_field(self.jobject, "numericStats", "Lweka/experiment/Stats;")) @property def total_count(self): """ The total number of values. :return: The total number of values :rtype: int """ return javabridge.get_field(self.jobject, "totalCount", "I") @property def unique_count(self): """ The number of values that only appear once. :return: The number of values that only appear once :rtype: int """ return javabridge.get_field(self.jobject, "uniqueCount", "I") class Stats(JavaObject): """ Container for numeric attribute stats. """ def __init__(self, jobject): """ Initializes the container. :param jobject: The Java object to wrap :type jobject: JB_Object """ self.enforce_type(jobject, "weka.experiment.Stats") super(Stats, self).__init__(jobject) @property def count(self): """ The number of values seen. :return: The number of values seen :rtype: float """ return javabridge.get_field(self.jobject, "count", "D") @property def min(self): """ The minimum value seen, or Double.NaN if no values seen. :return: The minimum value seen, or Double.NaN if no values seen :rtype: float """ return javabridge.get_field(self.jobject, "min", "D") @property def max(self): """ The maximum value seen, or Double.NaN if no values seen. :return: The maximum value seen, or Double.NaN if no values seen :rtype: float """ return javabridge.get_field(self.jobject, "max", "D") @property def mean(self): """ The mean of values at the last calculateDerived() call. :return: The mean of values at the last calculateDerived() call :rtype: float """ return javabridge.get_field(self.jobject, "mean", "D") @property def stddev(self): """ The std deviation of values at the last calculateDerived() call :return: The std deviation of values at the last calculateDerived() call :rtype: float """ return javabridge.get_field(self.jobject, "stdDev", "D") @property def sum(self): """ The sum of values seen. :return: The sum of values seen :rtype: float """ return javabridge.get_field(self.jobject, "sum", "D") @property def sumsq(self): """ The sum of values squared seen. :return: The sum of values squared seen :rtype: float """ return javabridge.get_field(self.jobject, "sumSq", "D") class InstanceIterator(object): """ Iterator for rows in an Instances object. """ def __init__(self, data): """ :param data: the Instances object to iterate over :type data: Instances """ self.data = data self.row = 0 def __iter__(self): """ Returns itself. """ return self def next(self): """ Returns the next row from the Instances object. :return: the next Instance object :rtype: Instance """ if self.row < self.data.num_instances: index = self.row self.row += 1 return self.data.get_instance(index) else: raise StopIteration() class AttributeIterator(object): """ Iterator for attributes in an Instances object. """ def __init__(self, data): """ :param data: the Instances object to iterate over :type data: Instances """ self.data = data self.col = 0 def __iter__(self): """ Returns itself. """ return self def next(self): """ Returns the next attribute from the Instances object. :return: the next Attribute object :rtype: Attribute """ if self.col < self.data.num_attributes: index = self.col self.col += 1 return self.data.attribute(index) else: raise StopIteration() class InstanceValueIterator(object): """ Iterator for values in an Instance object. """ def __init__(self, data): """ :param data: the Instance object to iterate over :type data: Instance """ self.data = data self.col = 0 def __iter__(self): """ Returns itself. """ return self def next(self): """ Returns the next value from the Instance object. :return: the next value, depending on the attribute that can be either a number of a string :rtype: str or float """ if self.col < self.data.num_attributes: index = self.col self.col += 1 if self.data.dataset.attribute(index).is_numeric: return self.data.get_value(index) else: return self.data.get_string_value(index) else: raise StopIteration() python-weka-wrapper-0.2.2/python/weka/core/converters.py0000644017267001726700000002023312446346264025046 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # converters.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge from weka.core.classes import OptionHandler from weka.core.capabilities import Capabilities from weka.core.dataset import Instances, Instance class Loader(OptionHandler): """ Wrapper class for Loaders. """ def __init__(self, classname="weka.core.converters.ArffLoader", jobject=None, options=None): """ Initializes the specified loader either using the classname or the JB_Object. :param classname: the classname of the loader :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ if jobject is None: jobject = Loader.new_instance(classname) self.enforce_type(jobject, "weka.core.converters.Loader") super(Loader, self).__init__(jobject=jobject, options=options) self.incremental = False self.structure = None def __iter__(self): """ Returns an iterator in case the loader was instantiated in incremental mode, otherwise an Exception is raised. :return: the iterator :rtype: IncrementalLoaderIterator """ if not self.incremental: raise Exception("Not in incremental mode, cannot iterate!") return IncrementalLoaderIterator(self, self.structure) def load_file(self, dfile, incremental=False): """ Loads the specified file and returns the Instances object. In case of incremental loading, only the structure. :param dfile: the file to load :type dfile: str :param incremental: whether to load the dataset incrementally :type incremental: bool :return: the full dataset or the header (if incremental) :rtype: Instances """ self.enforce_type(self.jobject, "weka.core.converters.FileSourcedConverter") self.incremental = incremental if not javabridge.is_instance_of(dfile, "Ljava/io/File;"): dfile = javabridge.make_instance( "Ljava/io/File;", "(Ljava/lang/String;)V", javabridge.get_env().new_string_utf(str(dfile))) javabridge.call(self.jobject, "reset", "()V") javabridge.call(self.jobject, "setFile", "(Ljava/io/File;)V", dfile) if incremental: self.structure = Instances(javabridge.call(self.jobject, "getStructure", "()Lweka/core/Instances;")) return self.structure else: return Instances(javabridge.call(self.jobject, "getDataSet", "()Lweka/core/Instances;")) def load_url(self, url, incremental=False): """ Loads the specified URL and returns the Instances object. In case of incremental loading, only the structure. :param url: the URL to load the data from :type url: str :param incremental: whether to load the dataset incrementally :type incremental: bool :return: the full dataset or the header (if incremental) :rtype: Instances """ self.enforce_type(self.jobject, "weka.core.converters.URLSourcedLoader") self.incremental = incremental javabridge.call(self.jobject, "reset", "()V") javabridge.call(self.jobject, "setURL", "(Ljava/lang/String;)V", str(url)) if incremental: self.structure = Instances(javabridge.call(self.jobject, "getStructure", "()Lweka/core/Instances;")) return self.structure else: return Instances(javabridge.call(self.jobject, "getDataSet", "()Lweka/core/Instances;")) class IncrementalLoaderIterator(object): """ Iterator for dataset rows when loarding incrementally. """ def __init__(self, loader, structure): """ :param loader: the loader instance to use for loading the data incrementally :type loader: Loader :param structure: the dataset structure :type structure: Instances """ self.loader = loader self.structure = structure def __iter__(self): """ Returns itself. """ return self def next(self): """ Reads the next dataset row. :return: the next row :rtype: Instance """ result = javabridge.call( self.loader.jobject, "getNextInstance", "(Lweka/core/Instances;)Lweka/core/Instance;", self.structure.jobject) if result is None: raise StopIteration() else: return Instance(result) class Saver(OptionHandler): """ Wrapper class for Savers. """ def __init__(self, classname="weka.core.converters.ArffSaver", jobject=None, options=None): """ Initializes the specified saver either using the classname or the provided JB_Object. :param classname: the classname of the saver :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to use :type options: list """ if jobject is None: jobject = Saver.new_instance(classname) self.enforce_type(jobject, "weka.core.converters.Saver") super(Saver, self).__init__(jobject=jobject, options=options) def capabilities(self): """ Returns the capabilities of the saver. :return: the capabilities :rtype: Capabilities """ return Capabilities(javabridge.call(self.jobject, "getCapabilities", "()Lweka/core/Capabilities;")) def save_file(self, data, dfile): """ Saves the Instances object in the specified file. :param data: the data to save :type data: Instances :param dfile: the file to save the data to :type dfile: str """ self.enforce_type(self.jobject, "weka.core.converters.FileSourcedConverter") if not javabridge.is_instance_of(dfile, "Ljava/io/File;"): dfile = javabridge.make_instance( "Ljava/io/File;", "(Ljava/lang/String;)V", javabridge.get_env().new_string_utf(str(dfile))) javabridge.call(self.jobject, "setFile", "(Ljava/io/File;)V", dfile) javabridge.call(self.jobject, "setInstances", "(Lweka/core/Instances;)V", data.jobject) javabridge.call(self.jobject, "writeBatch", "()V") def loader_for_file(filename): """ Returns a Loader that can load the specified file, based on the file extension. None if failed to determine. :param filename: the filename to get the loader for :type filename: str :return: the assoicated loader instance or None if none found :rtype: Loader """ loader = javabridge.static_call( "weka/core/converters/ConverterUtils", "getLoaderForFile", "(Ljava/lang/String;)Lweka/core/converters/AbstractFileLoader;", filename) if loader is None: return None else: return Loader(jobject=loader) def saver_for_file(filename): """ Returns a Saver that can load the specified file, based on the file extension. None if failed to determine. :param filename: the filename to get the saver for :type filename: str :return: the associated saver instance or None if none found :rtype: Saver """ saver = javabridge.static_call( "weka/core/converters/ConverterUtils", "getSaverForFile", "(Ljava/lang/String;)Lweka/core/converters/AbstractFileSaver;", filename) if saver is None: return None else: return Saver(jobject=saver) python-weka-wrapper-0.2.2/python/weka/core/jvm.py0000644017267001726700000000776012443672527023463 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # jvm.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import os import glob import logging started = None # logging setup logging.basicConfig(level=logging.DEBUG) logger = logging.getLogger(__name__) def add_bundled_jars(): """ Adds the bundled jars to the JVM's classpath. """ # determine lib directory with jars rootdir = os.path.split(os.path.dirname(__file__))[0] libdir = rootdir + os.sep + "lib" # add jars from lib directory for l in glob.glob(libdir + os.sep + "*.jar"): if l.lower().find("-src.") == -1: javabridge.JARS.append(str(l)) def add_weka_packages(): """ Adds the jars from all Weka packages to the JVM's classpath. """ prefix = os.getenv("WEKA_HOME", "~") package_dir = os.path.expanduser(prefix + os.sep + "wekafiles" + os.sep + "packages") logger.debug("package_dir=" + package_dir) # traverse packages for p in os.listdir(package_dir): if os.path.isdir(package_dir + os.sep + p): directory = package_dir + os.sep + p logger.debug(" directory=" + directory) # inspect package directory for l in os.listdir(directory): if l.lower().endswith(".jar"): javabridge.JARS.append(directory + os.sep + l) if l == "lib": for m in glob.glob(directory + os.sep + "lib" + os.sep + "*.jar"): javabridge.JARS.append(m) def add_system_classpath(): """ Adds the system's classpath to the JVM's classpath. """ if not os.environ['CLASSPATH'] is None: parts = os.environ['CLASSPATH'].split(os.pathsep) for part in parts: javabridge.JARS.append(part) def start(class_path=None, bundled=True, packages=False, system_cp=False, max_heap_size=None): """ Initializes the javabridge connection (starts up the JVM). :param class_path: the additional classpath elements to add :type class_path: str :param bundled: whether to add jars from the "lib" directory :type bundled: bool :param packages: whether to add jars from Weka packages as well :type packages: bool :param system_cp: whether to add the system classpath as well :type system_cp: bool :param max_heap_size: the maximum heap size (-Xmx parameter, eg 512m or 4g) :type max_heap_size: str """ global started if not started is None: logger.info("JVM already running, call jvm.stop() first") return # add user-defined jars first if not class_path is None: for cp in class_path: logger.debug("Adding user-supplied classpath=" + cp) javabridge.JARS.append(cp) if bundled: logger.debug("Adding bundled jars") add_bundled_jars() if packages: logger.debug("Adding Weka packages") add_weka_packages() if system_cp: logger.debug("Adding system classpath") add_system_classpath() logger.debug("Classpath=" + str(javabridge.JARS)) logger.debug("MaxHeapSize=" + ("default" if (max_heap_size is None) else max_heap_size)) javabridge.start_vm(run_headless=True, max_heap_size=max_heap_size) javabridge.attach() started = True def stop(): """ Kills the JVM. """ global started if not started is None: started = None javabridge.kill_vm() python-weka-wrapper-0.2.2/python/weka/core/serialization.py0000644017267001726700000000613112443672536025533 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # serialization.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging from weka.core.classes import JavaObject # logging setup logger = logging.getLogger(__name__) def read(filename): """ Reads the serialized object from disk. Caller must wrap object in appropriate Python wrapper class. :param filename: the file with the serialized object :type filename: str :return: the JB_Object :rtype: JB_Object """ return javabridge.static_call( "Lweka/core/SerializationHelper;", "read", "(Ljava/lang/String;)Ljava/lang/Object;", filename) def read_all(filename): """ Reads the serialized objects from disk. Caller must wrap objects in appropriate Python wrapper classes. :param filename: the file with the serialized objects :type filename: str :return: the list of JB_OBjects :rtype: list """ array = javabridge.static_call( "Lweka/core/SerializationHelper;", "readAll", "(Ljava/lang/String;)[Ljava/lang/Object;", filename) if array is None: return None else: return javabridge.get_env().get_object_array_elements(array) def write(filename, jobject): """ Serializes the object to disk. JavaObject instances get automatically unwrapped :param filename: the file to serialize the object to :type filename: str :param jobject: the object to serialize :type jobject: JB_Object or JavaObject """ if isinstance(jobject, JavaObject): jobject = jobject.jobject javabridge.static_call( "Lweka/core/SerializationHelper;", "write", "(Ljava/lang/String;Ljava/lang/Object;)V", filename, jobject) def write_all(filename, jobjects): """ Serializes the list of objects to disk. JavaObject instances get automatically unwrapped :param filename: the file to serialize the object to :type filename: str :param jobjects: the list of objects to serialize :type jobjects: list """ array = javabridge.get_env().make_object_array(len(jobjects), javabridge.get_env().find_class("java/lang/Object")) for i in xrange(len(jobjects)): obj = jobjects[i] if isinstance(obj, JavaObject): obj = obj.jobject javabridge.get_env().set_object_array_element(array, i, obj) javabridge.static_call( "Lweka/core/SerializationHelper;", "writeAll", "(Ljava/lang/String;[Ljava/lang/Object;)V", filename, array) python-weka-wrapper-0.2.2/python/weka/core/packages.py0000644017267001726700000002522212452314622024423 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # packages.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import weka.core.jvm as jvm from weka.core.classes import JavaObject class Package(JavaObject): """ Wrapper for the org.pentaho.packageManagement.Package class. """ def __init__(self, jobject): """ Initializes the wrapper. :param jobject: the java Package instance to wrap :type jobject: JB_Object """ self.enforce_type(jobject, "org.pentaho.packageManagement.Package") super(Package, self).__init__(jobject) @property def name(self): """ Returns the name of the package. :return: the name :rtype: str """ return javabridge.call(self.jobject, "getName", "()Ljava/lang/String;") @property def url(self): """ Returns the URL of the package. :return: the url :rtype: str """ return str(JavaObject(javabridge.call(self.jobject, "getPackageURL", "()Ljava/net/URL;"))) @property def dependencies(self): """ Returns the dependencies of the package. :return: the list of Dependency objects :rtype: list of Dependency """ result = [] dependencies = javabridge.get_collection_wrapper( javabridge.call(self.jobject, "getDependencies", "()Ljava/util/List;")) for dependency in dependencies: result.append(Dependency(dependency)) return result @property def metadata(self): """ Returns the meta-data. :return: the meta-data dictionary :rtype: dict """ return javabridge.get_dictionary_wrapper( javabridge.call(self.jobject, "getPackageMetaData", "()Ljava/util/Map;")) @property def is_installed(self): """ Returns whether the package is installed. :return: whether installed :rtype: bool """ return javabridge.call(self.jobject, "isInstalled", "()Z") def install(self): """ Installs the package. """ return javabridge.call(self.jobject, "install", "()V") class PackageConstraint(JavaObject): """ Wrapper for the org.pentaho.packageManagement.PackageConstraint class. """ def __init__(self, jobject): """ Initializes the wrapper. :param jobject: the java PackageConstraint instance to wrap :type jobject: JB_Object """ self.enforce_type(jobject, "org.pentaho.packageManagement.PackageConstraint") super(PackageConstraint, self).__init__(jobject) def set_package(self, pkge): """ Sets the package. :param pkge: the package :type pkge: Package """ javabridge.call(self.jobject, "setPackage", "(Lorg/pentaho/packageManagement/Package;)V", pkge.jobject) def get_package(self): """ Returns the package. :return: the package :rtype: Package """ return Package(javabridge.call(self.jobject, "getPackage", "()Lorg/pentaho/packageManagement/Package;")) def check_constraint(self, pkge=None, constr=None): """ Checks the constraing. :param pkge: the package to check :type pkge: Package :param constr: the package constraint to check :type constr: PackageConstraint """ if not pkge is None: return javabridge.call( self.jobject, "checkConstraint", "(Lorg/pentaho/packageManagement/Package;)Z", pkge.jobject) if not constr is None: return javabridge.call( self.jobject, "checkConstraint", "(Lorg/pentaho/packageManagement/PackageConstraint;)Z", pkge.jobject) raise Exception("Either package or package constraing must be provided!") class Dependency(JavaObject): """ Wrapper for the org.pentaho.packageManagement.Dependency class. """ def __init__(self, jobject): """ Initializes the wrapper. :param jobject: the java Dependency instance to wrap :type jobject: JB_Object """ self.enforce_type(jobject, "org.pentaho.packageManagement.Dependency") super(Dependency, self).__init__(jobject) @property def source(self): """ Returns the source package. :return: the package :rtype: Package """ return Package( javabridge.call(self.jobject, "getSource", "()Lorg/pentaho/packageManagement/Package;")) @source.setter def source(self, pkge): """ Sets the source package. :param pkge: the package :type pkge: Package """ javabridge.call( self.jobject, "setSource", "(Lorg/pentaho/packageManagement/Package;)V", pkge.jobject) @property def target(self): """ Returns the target package constraint. :return: the package constraint :rtype: PackageConstraint """ return PackageConstraint( javabridge.call(self.jobject, "getTarget", "()Lorg/pentaho/packageManagement/PackageConstraint;")) @target.setter def target(self, constr): """ Sets the target package constraint. :param constr: the package constraint :type constr: Package """ javabridge.call( self.jobject, "setTarget", "(Lorg/pentaho/packageManagement/PackageConstraint;)V", constr.jobject) def establish_cache(): """ Establishes the package cache if necessary. """ javabridge.static_call( "weka/core/WekaPackageManager", "establishCacheIfNeeded", "([Ljava/io/PrintStream;)Ljava/lang/Exception;", []) def refresh_cache(): """ Refreshes the cache. """ establish_cache() javabridge.static_call( "weka/core/WekaPackageManager", "refreshCache", "([Ljava/io/PrintStream;)Ljava/lang/Exception;", []) def all_packages(): """ Returns a list of all packages. :return: the list of packages :rtype: list """ establish_cache() result = [] pkgs = javabridge.get_collection_wrapper( javabridge.static_call( "weka/core/WekaPackageManager", "getAllPackages", "()Ljava/util/List;")) for pkge in pkgs: result.append(Package(pkge)) return result def available_packages(): """ Returns a list of all packages that aren't installed yet. :return: the list of packages :rtype: list """ establish_cache() result = [] pkgs = javabridge.get_collection_wrapper( javabridge.static_call( "weka/core/WekaPackageManager", "getAvailablePackages", "()Ljava/util/List;")) for pkge in pkgs: result.append(Package(pkge)) return result def installed_packages(): """ Returns a list of the installed packages. :return: the list of packages :rtype: list """ establish_cache() result = [] pkgs = javabridge.get_collection_wrapper( javabridge.static_call( "weka/core/WekaPackageManager", "getInstalledPackages", "()Ljava/util/List;")) for pkge in pkgs: result.append(Package(pkge)) return result def install_package(pkge, version="Latest"): """ The list of packages to install. :param pkge: the name of the repository package, a URL (http/https) or a zip file :type pkge: str :param version: in case of the repository packages, the version :type version: str :return: whether successfully installed :rtype: bool """ establish_cache() if pkge.startswith("http://") or pkge.startswith("https://"): url = javabridge.make_instance( "java/net/URL", "(Ljava/lang/String;)V", javabridge.get_env().new_string_utf(pkge)) return not javabridge.static_call( "weka/core/WekaPackageManager", "installPackageFromURL", "(Ljava/net/URL;[Ljava/io/PrintStream;)Ljava/lang/String;", url, []) is None elif pkge.lower().endswith(".zip"): return not javabridge.static_call( "weka/core/WekaPackageManager", "installPackageFromArchive", "(Ljava/lang/String;[Ljava/io/PrintStream;)Ljava/lang/String;", pkge, []) is None else: return javabridge.static_call( "weka/core/WekaPackageManager", "installPackageFromRepository", "(Ljava/lang/String;Ljava/lang/String;[Ljava/io/PrintStream;)Z", pkge, version, []) def uninstall_package(name): """ Uninstalls a package. :param name: the name of the package :type name: str :return: whether successfully uninstalled :rtype: bool """ establish_cache() javabridge.static_call( "weka/core/WekaPackageManager", "uninstallPackage", "(Ljava/lang/String;Z[Ljava/io/PrintStream;)V", name, True, []) def is_installed(name): """ Checks whether a package with the name is already installed. :param name: the name of the package :type name: str :return: whether the package is installed :rtype: bool """ pkgs = installed_packages() for pkge in pkgs: if pkge.name == name: return True return False if __name__ == "__main__": jvm.start() try: print("Establish cache") print("===============") establish_cache() print("Refresh cache") print("=============") refresh_cache() print("All packages") print("============") packages = all_packages() for pkg in packages: print(pkg.name) print(" url: " + pkg.url) print("") print("Available packages") print("==================") packages = available_packages() p = packages[0] for pkg in packages: print(pkg.name) print(" url: " + pkg.url) print("") print("Installed packages") print("==================") packages = installed_packages() for pkg in packages: print(pkg.name) print(" url: " + pkg.url) print("") except Exception, e: print(e) finally: jvm.stop() python-weka-wrapper-0.2.2/python/weka/core/types.py0000644017267001726700000000575512452314622024022 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # types.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging import numpy # logging setup logger = logging.getLogger(__name__) def string_array_to_list(a): """ Turns the Java string array into Python unicode string list. :param a: the string array to convert :type a: JB_Object :return: the string list :rtype: list """ result = [] length = javabridge.get_env().get_array_length(a) wrapped = javabridge.get_env().get_object_array_elements(a) for i in xrange(length): result.append(javabridge.get_env().get_string(wrapped[i])) return result def string_list_to_array(l): """ Turns a Python unicode string list into a Java String array. :param l: the string list :type: list :rtype: java string array :return: JB_Object """ result = javabridge.get_env().make_object_array(len(l), javabridge.get_env().find_class("java/lang/String")) for i in xrange(len(l)): javabridge.get_env().set_object_array_element(result, i, javabridge.get_env().new_string_utf(l[i])) return result def double_matrix_to_ndarray(m): """ Turns the Java matrix (2-dim array) of doubles into a numpy 2-dim array. :param m: the double matrix :type: JB_Object :return: Numpy array :rtype: numpy.darray """ rows = javabridge.get_env().get_object_array_elements(m) num = javabridge.get_env().get_array_length(m) result = numpy.zeros(num * num).reshape((num, num)) i = 0 for row in rows: elements = javabridge.get_env().get_double_array_elements(row) n = 0 for element in elements: result[i][n] = element n += 1 i += 1 return result def enumeration_to_list(enm): """ Turns the java.util.Enumeration into a list. :param enm: the enumeration to convert :type enm: JB_Object :return: the list :rtype: list """ result = [] while javabridge.call(enm, "hasMoreElements", "()Z"): result.append(javabridge.call(enm, "nextElement", "()Ljava/lang/Object;")) return result def double_to_float(d): """ Turns the Python float into a Java java.lang.Float object. :param d: the Python float :type d: float :return: the Float object :rtype: JB_Object """ return javabridge.make_instance("java/lang/Float", "(D)V", d) python-weka-wrapper-0.2.2/python/weka/core/capabilities.py0000644017267001726700000003563612452314622025310 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # capabilities.py # Copyright (C) 2014-2015 Fracpete (pythonwekawrapper at gmail dot com) import javabridge from weka.core.classes import JavaObject, Enum from weka.core.dataset import Attribute, Instances class Capability(Enum): """ Wrapper for a Capability. """ def __init__(self, jobject=None, member=None): """ Initializes the wrapper with the specified Capability object. :param jobject: the Capability object to wrap :type jobject: JB_Object :param member: the capability string to parse :type member: str """ super(Capability, self).__init__(\ jobject=jobject, enum="weka.core.Capabilities$Capability", member=member) @property def is_attribute(self): """ Returns whether this capability is an attribute. :return: whether it is an attribute :rtype: bool """ return javabridge.call(self.jobject, "isAttribute", "()Z") @property def is_attribute_capability(self): """ Returns whether this capability is an attribute capability. :return: whether it is an attribute capability :rtype: bool """ return javabridge.call(self.jobject, "isAttributeCapability", "()Z") @property def is_class(self): """ Returns whether this capability is a class. :return: whether it is a class :rtype: bool """ return javabridge.call(self.jobject, "isClass", "()Z") @property def is_class_capability(self): """ Returns whether this capability is a class capability. :return: whether it is a class capability :rtype: bool """ return javabridge.call(self.jobject, "isClassCapability", "()Z") @property def is_other_capability(self): """ Returns whether this capability is an other capability. :return: whether it is an other capability :rtype: bool """ return javabridge.call(self.jobject, "isOtherCapability", "()Z") class Capabilities(JavaObject): """ Wrapper for Capabilities. """ def __init__(self, jobject=None, owner=None): """ Initializes the wrapper with the specified Capabilities object. :param jobject: the Capabilities object to wrap, instantiates a new one if None :type jobject: JB_Object :param owner: the weka.core.CapabilitiesHandler object to use as owner, can be None :type owner: JB_Object or JavaObject """ if jobject is None: if isinstance(owner, JavaObject): owner = owner.jobject jobject = javabridge.make_instance( "weka/core/Capabilities", "(Lweka/core/CapabilitiesHandler;)V", owner) Capabilities.enforce_type(jobject, "weka.core.Capabilities") super(Capabilities, self).__init__(jobject) @property def owner(self): """ Returns the owner of these capabilities, if any. :return: the owner, can be None :rtype: JavaObject """ obj = javabridge.call(self.jobject, "getOwner", "()Lweka/core/CapabilitiesHandler;") if obj is None: return None else: return JavaObject(jobject=obj) @owner.setter def owner(self, obj): """ Sets the new owner. :param obj: the new owner :type obj: JavaObject or JB_Object """ if isinstance(obj, JavaObject): obj = obj.jobject javabridge.call(self.jobject, "setOwner", "(Lweka/core/CapabilitiesHandler;)V", obj) def capabilities(self): """ Returns all the capabilities. :return: all capabilities :rtype: list """ result = [] iterator = javabridge.iterate_java(javabridge.call(self.jobject, "capabilities", "()Ljava/util/Iterator;")) for c in iterator: result.append(Capability(c)) return result def attribute_capabilities(self): """ Returns all the attribute capabilities. :return: attribute capabilities :rtype: Capabilities """ return Capabilities( javabridge.call(self.jobject, "getAttributeCapabilities", "()Lweka/core/Capabilities;")) def class_capabilities(self): """ Returns all the class capabilities. :return: class capabilities :rtype: Capabilities """ return Capabilities( javabridge.call(self.jobject, "getClassCapabilities", "()Lweka/core/Capabilities;")) def other_capabilities(self): """ Returns all other capabilities. :return: all other capabilities :rtype: Capabilities """ return Capabilities( javabridge.call(self.jobject, "getOtherCapabilities", "()Lweka/core/Capabilities;")) def dependencies(self): """ Returns all the dependencies. :return: the dependency list :rtype: list """ result = [] iterator = javabridge.iterate_java(javabridge.call(self.jobject, "dependencies", "()Ljava/util/Iterator;")) for c in iterator: result.append(Capability(c)) return result def handles(self, capability): """ Returns whether the specified capability is set :param capability: the capability to check :type capability: Capability :return: whether the capability is set :rtype: bool """ return javabridge.call( self.jobject, "handles", "(Lweka/core/Capabilities$Capability;)Z", capability.jobject) def enable_all(self): """ enables all capabilities. """ javabridge.call(self.jobject, "enableAll", "()V") def enable_all_attributes(self): """ enables all attributes. """ javabridge.call(self.jobject, "enableAllAttributes", "()V") def enable_all_classes(self): """ enables all classes. """ javabridge.call(self.jobject, "enableAllClasses", "()V") def enable(self, capability): """ enables the specified capability. :param capability: the capability to enable :type capability: Capability """ javabridge.call(self.jobject, "enable", "(Lweka/core/Capabilities$Capability;)V", capability.jobject) def enable_all_attribute_dependencies(self): """ enables all attribute dependencies. """ javabridge.call(self.jobject, "enableAllAttributeDependencies", "()V") def enable_all_class_dependencies(self): """ enables all class dependencies. """ javabridge.call(self.jobject, "enableAllClassDependencies", "()V") def enable_dependency(self, capability): """ enables the dependency of the given capability enabling NOMINAL_ATTRIBUTES also enables BINARY_ATTRIBUTES, UNARY_ATTRIBUTES and EMPTY_NOMINAL_ATTRIBUTES. :param capability: the dependency to enable :type capability: Capability """ javabridge.call( self.jobject, "enableDependency", "(Lweka/core/Capabilities$Capability;)V", capability.jobject) def disable_all(self): """ Disables all capabilities. """ javabridge.call(self.jobject, "disableAll", "()V") def disable_all_attributes(self): """ Disables all attributes. """ javabridge.call(self.jobject, "disableAllAttributes", "()V") def disable_all_classes(self): """ Disables all classes. """ javabridge.call(self.jobject, "disableAllClasses", "()V") def disable(self, capability): """ Disables the specified capability. :param capability: the capability to disable :type capability: Capability """ javabridge.call(self.jobject, "disable", "(Lweka/core/Capabilities$Capability;)V", capability.jobject) def disable_all_attribute_dependencies(self): """ Disables all attribute dependencies. """ javabridge.call(self.jobject, "disableAllAttributeDependencies", "()V") def disable_all_class_dependencies(self): """ Disables all class dependencies. """ javabridge.call(self.jobject, "disableAllClassDependencies", "()V") def disable_dependency(self, capability): """ Disables the dependency of the given capability Disabling NOMINAL_ATTRIBUTES also disables BINARY_ATTRIBUTES, UNARY_ATTRIBUTES and EMPTY_NOMINAL_ATTRIBUTES. :param capability: the dependency to disable :type capability: Capability """ javabridge.call( self.jobject, "disableDependency", "(Lweka/core/Capabilities$Capability;)V", capability.jobject) def has_dependencies(self): """ Returns whether any dependencies are set. :return: whether any dependecies are set :rtype: bool """ return javabridge.call(self.jobject, "hasDependencies", "()Z") def has_dependency(self, capability): """ Returns whether the specified dependency is set :param capability: the capability to check :type capability: Capability :return: whether the dependency is set :rtype: bool """ return javabridge.call( self.jobject, "hasDependency", "(Lweka/core/Capabilities$Capability;)Z", capability.jobject) def supports(self, capabilities): """ Returns true if the currently set capabilities support at least all of the capabiliites of the given Capabilities object (checks only the enum!) :param capabilities: the capabilities to check :type capabilities: Capabilities :return: whether the current capabilities support at least the specified ones :rtype: bool """ return javabridge.call(self.jobject, "supports", "(Lweka/core/Capabilities;)Z", capabilities.jobject) def supports_maybe(self, capabilities): """ Returns true if the currently set capabilities support (or have a dependency) at least all of the capabilities of the given Capabilities object (checks only the enum!) :param capabilities: the capabilities to check :type capabilities: Capabilities :return: whether the current capabilities (potentially) support the specified ones :rtype: bool """ return javabridge.call(self.jobject, "supportsMaybe", "(Lweka/core/Capabilities;)Z", capabilities.jobject) @property def min_instances(self): """ Returns the minimum number of instances that must be supported. :return: the minimum number :rtype: int """ return javabridge.call(self.jobject, "getMinimumNumberInstances", "()I") @min_instances.setter def min_instances(self, minimum): """ Sets the minimum number of instances that must be supported. :param minimum: the minimum number :type minimum: int """ javabridge.call(self.jobject, "setMinimumNumberInstances", "(I)V", minimum) def test_attribute(self, att, is_class=None, fail=False): """ Tests whether the attribute meets the conditions. :param att: the Attribute to test :type att: Attribute :param is_class: whether this attribute is the class attribute :type is_class: bool :param fail: whether to fail with an exception in case the test fails :type fail: bool :return: whether the attribute meets the conditions :rtype: bool """ if fail: if is_class is None: return javabridge.call( self.jobject, "test", "(Lweka/core/Attribute;)Z", att.jobject) else: return javabridge.call( self.jobject, "test", "(Lweka/core/Attribute;Z)Z", att.jobject, is_class) else: if is_class is None: return javabridge.call( self.jobject, "testWithFail", "(Lweka/core/Attribute;)Z", att.jobject) else: return javabridge.call( self.jobject, "testWithFail", "(Lweka/core/Attribute;Z)Z", att.jobject, is_class) def test_instances(self, data, from_index=None, to_index=None, fail=False): """ Tests whether the dataset meets the conditions. :param data: the Instances to test :type data: Instances :param from_index: the first attribute to include :type from_index: int :param to_index: the last attribute to include :type to_index: int :return: wether the dataset meets the requirements :rtype: bool """ if fail: if (from_index is None) or (to_index is None): return javabridge.call( self.jobject, "test", "(Lweka/core/Instances;)Z", data.jobject) else: return javabridge.call( self.jobject, "test", "(Lweka/core/Instances;II)Z", data.jobject, from_index, to_index) else: if (from_index is None) or (to_index is None): return javabridge.call( self.jobject, "testWithFail", "(Lweka/core/Instances;)Z", data.jobject) else: return javabridge.call( self.jobject, "testWithFail", "(Lweka/core/Instances;II)Z", data.jobject, from_index, to_index) @classmethod def for_instances(cls, data, multi=None): """ returns a Capabilities object specific for this data. The minimum number of instances is not set, the check for multi-instance data is optional. :param data: the data to generate the capabilities for :type data: Instances :param multi: whether to check the structure, too :type multi: bool :return: the generated capabilities :rtype: Capabilities """ if multi is None: return Capabilities(javabridge.static_call( "weka/core/Capabilities", "forInstances", "(Lweka/core/Instances;)Lweka/core/Capabilities;", data.jobject)) else: return Capabilities(javabridge.static_call( "weka/core/Capabilities", "forInstances", "(Lweka/core/Instances;Z)Lweka/core/Capabilities;", data.jobject, multi)) python-weka-wrapper-0.2.2/python/weka/core/__init__.py0000644017267001726700000000000012322574641024374 0ustar fracpetefracpete00000000000000python-weka-wrapper-0.2.2/python/weka/core/version.py0000644017267001726700000000172412446346264024345 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # version.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) from weka.core.classes import JavaObject def weka_version(): """ Determines the version of Weka in use. :return: the version :rtype: str """ jobj = JavaObject(JavaObject.new_instance(classname="weka.core.Version")) return str(jobj) python-weka-wrapper-0.2.2/python/weka/classifiers.py0000644017267001726700000016466212452370714024244 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # classifiers.py # Copyright (C) 2014-2015 Fracpete (pythonwekawrapper at gmail dot com) import sys import os import javabridge import logging import argparse import weka.core.jvm as jvm import weka.core.utils as wutils import weka.core.types as arrays from numpy import * from weka.core.classes import JavaObject from weka.core.classes import OptionHandler from weka.core.classes import Random from weka.core.capabilities import Capabilities from weka.core.dataset import Instances, Instance, Attribute from weka.filters import Filter # logging setup logger = logging.getLogger("weka.classifiers") class Classifier(OptionHandler): """ Wrapper class for classifiers. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified classifier using either the classname or the supplied JB_Object. :param classname: the classname of the classifier :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ if jobject is None: jobject = Classifier.new_instance(classname) self.enforce_type(jobject, "weka.classifiers.Classifier") self.is_updateable = self.check_type(jobject, "weka.classifiers.UpdateableClassifier") self.is_drawable = self.check_type(jobject, "weka.core.Drawable") super(Classifier, self).__init__(jobject=jobject, options=options) self.__classify = javabridge.make_call(self.jobject, "classifyInstance", "(Lweka/core/Instance;)D") self.__distribution = javabridge.make_call(self.jobject, "distributionForInstance", "(Lweka/core/Instance;)[D") @property def capabilities(self): """ Returns the capabilities of the classifier. :return: the capabilities :rtype: Capabilities """ return Capabilities(javabridge.call(self.jobject, "getCapabilities", "()Lweka/core/Capabilities;")) def build_classifier(self, data): """ Builds the classifier with the data. :param data: the data to train the classifier with :type data: Instances """ javabridge.call(self.jobject, "buildClassifier", "(Lweka/core/Instances;)V", data.jobject) def update_classifier(self, inst): """ Updates the classifier with the instance. :param inst: the Instance to update the classifier with :type inst: Instance """ if self.is_updateable: javabridge.call(self.jobject, "updateClassifier", "(Lweka/core/Instance;)V", inst.jobject) else: logger.critical(wutils.get_classname(self.jobject) + " is not updateable!") def classify_instance(self, inst): """ Peforms a prediction. :param inst: the Instance to get a prediction for :type inst: Instance :return: the classification (either regression value or 0-based label index) :rtype: float """ return self.__classify(inst.jobject) def distribution_for_instance(self, inst): """ Peforms a prediction, returning the class distribution. :param inst: the Instance to get the class distribution for :type inst: Instance :return: the class distribution array :rtype: ndarray """ pred = self.__distribution(inst.jobject) return javabridge.get_env().get_double_array_elements(pred) @property def graph_type(self): """ Returns the graph type if classifier implements weka.core.Drawable, otherwise -1. :return: the type :rtype: int """ if self.is_drawable: return javabridge.call(self.jobject, "graphType", "()I") else: return -1 @property def graph(self): """ Returns the graph if classifier implements weka.core.Drawable, otherwise None. :return: the generated graph string :rtype: str """ if self.is_drawable: return javabridge.call(self.jobject, "graph", "()Ljava/lang/String;") else: return None @classmethod def make_copy(cls, classifier): """ Creates a copy of the classifier. :param classifier: the classifier to copy :type classifier: Classifier :return: the copy of the classifier :rtype: Classifier """ return Classifier( jobject=javabridge.static_call( "weka/classifiers/AbstractClassifier", "makeCopy", "(Lweka/classifiers/Classifier;)Lweka/classifiers/Classifier;", classifier.jobject)) class SingleClassifierEnhancer(Classifier): """ Wrapper class for classifiers that use a single base classifier. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified classifier using either the classname or the supplied JB_Object. :param classname: the classname of the classifier :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ if jobject is None: jobject = Classifier.new_instance(classname) self.enforce_type(jobject, "weka.classifiers.SingleClassifierEnhancer") super(SingleClassifierEnhancer, self).__init__(classname=classname, jobject=jobject, options=options) @property def classifier(self): """ Returns the base classifier. :rtype: Classifier """ return Classifier(jobject=javabridge.call(self.jobject, "getClassifier", "()Lweka/classifiers/Classifier;")) @classifier.setter def classifier(self, classifier): """ Sets the base classifier. :param classifier: the base classifier to use """ javabridge.call(self.jobject, "setClassifier", "(Lweka/classifiers/Classifier;)V", classifier.jobject) class FilteredClassifier(SingleClassifierEnhancer): """ Wrapper class for the filtered classifier. """ def __init__(self, jobject=None, options=None): """ Initializes the specified classifier using either the classname or the supplied JB_Object. :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ classname = "weka.classifiers.meta.FilteredClassifier" if jobject is None: jobject = Classifier.new_instance(classname) else: self.enforce_type(jobject, classname) super(FilteredClassifier, self).__init__(jobject=jobject, options=options) @property def filter(self): """ Returns the filter. :return: the filter in use :rtype: Filter """ return Filter(jobject=javabridge.call(self.jobject, "getFilter", "()Lweka/filters/Filter;")) @filter.setter def filter(self, filtr): """ Sets the filter. :param filtr: the filter to use :type filtr: Filter """ javabridge.call(self.jobject, "setFilter", "(Lweka/filters/Filter;)V", filtr.jobject) class MultipleClassifiersCombiner(Classifier): """ Wrapper class for classifiers that use a multiple base classifiers. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified classifier using either the classname or the supplied JB_Object. :param classname: the classname of the classifier :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: list of commandline options :type options: list """ if jobject is None: jobject = Classifier.new_instance(classname) self.enforce_type(jobject, "weka.classifiers.MultipleClassifiersCombiner") super(MultipleClassifiersCombiner, self).__init__(classname=classname, jobject=jobject, options=options) @property def classifiers(self): """ Returns the list of base classifiers. :return: the classifier list :rtype: list """ objects = javabridge.get_env().get_object_array_elements( javabridge.call(self.jobject, "getClassifiers", "()[Lweka/classifiers/Classifier;")) result = [] for obj in objects: result.append(Classifier(jobject=obj)) return result @classifiers.setter def classifiers(self, classifiers): """ Sets the base classifiers. :param classifiers: the list of base classifiers to use :type classifiers: list """ obj = [] for classifier in classifiers: obj.append(classifier.jobject) javabridge.call(self.jobject, "setClassifiers", "([Lweka/classifiers/Classifier;)V", obj) class Kernel(OptionHandler): """ Wrapper class for kernels. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified kernel using either the classname or the supplied JB_Object. :param classname: the classname of the kernel :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ if jobject is None: jobject = Classifier.new_instance(classname) self.enforce_type(jobject, "weka.classifiers.functions.supportVector.Kernel") super(Kernel, self).__init__(jobject=jobject, options=options) def capabilities(self): """ Returns the capabilities of the classifier. :return: the capabilities :rtype: Capabilities """ return Capabilities(javabridge.call(self.jobject, "getCapabilities", "()Lweka/core/Capabilities;")) @property def checks_turned_off(self): """ Returns whether checks are turned off. :return: True if checks turned off :rtype: bool """ return javabridge.call(self.jobject, "getChecksTurnedOff", "()Z") @checks_turned_off.setter def checks_turned_off(self, off): """ Turns any checks on/off. :param off: True to turn off checks :type off: bool """ javabridge.call(self.jobject, "setChecksTurnedOff", "(Z)V", off) def clean(self): """ Frees the memory used by the kernel. """ javabridge.call(self.jobject, "clean", "()V") def build_kernel(self, data): """ Builds the classifier with the data. :param data: the data to train the classifier with :type data: Instances """ javabridge.call(self.jobject, "buildKernel", "(Lweka/core/Instances;)V", data.jobject) def eval(self, id1, id2, inst1): """ Computes the result of the kernel function for two instances. If id1 == -1, eval use inst1 instead of an instance in the dataset. :param id1: the index of the first instance in the dataset :type id1: int :param id2: the index of the second instance in the dataset :type id2: int :param inst1: the instance corresponding to id1 (used if id1 == -1) :type inst1: Instance """ jinst1 = None if not inst1 is None: jinst1 = inst1.jobject return javabridge.call(self.jobject, "eval", "(IILweka/core/Instance;)D", id1, id2, jinst1) @classmethod def make_copy(cls, kernel): """ Creates a copy of the kernel. :param kernel: the kernel to copy :type kernel: Kernel :return: the copy of the kernel :rtype: Kernel """ return Kernel( jobject=javabridge.static_call( "weka/classifiers/functions/supportVector/Kernel", "makeCopy", "(Lweka/classifiers/functions/supportVector/Kernel;)Lweka/classifiers/functions/supportVector/Kernel;", kernel.jobject)) class KernelClassifier(Classifier): """ Wrapper class for classifiers that have a kernel property, like SMO. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified classifier using either the classname or the supplied JB_Object. :param classname: the classname of the classifier :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: list of commandline options :type options: list """ if jobject is None: jobject = Classifier.new_instance(classname) self.enforce_type(jobject, "weka.classifiers.Classifier") if not javabridge.static_call( "weka/classifiers/KernelHelper", "hasKernelProperty", "(Ljava/lang/Object;)Z", jobject): raise Exception("Does not handle a kernel: " + wutils.get_classname(jobject)) super(KernelClassifier, self).__init__(classname=classname, jobject=jobject, options=options) @property def kernel(self): """ Returns the current kernel. :return: the kernel or None if none found :rtype: Kernel """ result = javabridge.static_call( "weka/classifiers/KernelHelper", "getKernel", "(Ljava/lang/Object;)Lweka/classifiers/functions/supportVector/Kernel;", self.jobject) if result is None: return None else: return Kernel(jobject=result) @kernel.setter def kernel(self, kernel): """ Sets the kernel. :param kernel: the kernel to set :type kernel: Kernel """ result = javabridge.static_call( "weka/classifiers/KernelHelper", "setKernel", "(Ljava/lang/Object;Lweka/classifiers/functions/supportVector/Kernel;)Z", self.jobject, kernel.jobject) if not result: raise Exception("Failed to set kernel!") class Prediction(JavaObject): """ Wrapper class for a prediction. """ def __init__(self, jobject): """ Initializes the wrapper. :param jobject: the prediction to wrap :type jobject: JB_Object """ self.enforce_type(jobject, "weka.classifiers.evaluation.Prediction") super(Prediction, self).__init__(jobject) @property def actual(self): """ Returns the actual value. :return: the actual value (internal representation) :rtype: float """ return javabridge.call(self.jobject, "actual", "()D") @property def predicted(self): """ Returns the predicted value. :return: the predicted value (internal representation) :rtype: float """ return javabridge.call(self.jobject, "predicted", "()D") @property def weight(self): """ Returns the weight. :return: the weight of the Instance that was used :rtype: float """ return javabridge.call(self.jobject, "weight", "()D") class NominalPrediction(Prediction): """ Wrapper class for a nominal prediction. """ def __init__(self, jobject): """ Initializes the wrapper. :param jobject: the prediction to wrap :type jobject: JB_Object """ self.enforce_type(jobject, "weka.classifiers.evaluation.NominalPrediction") super(NominalPrediction, self).__init__(jobject) @property def distribution(self): """ Returns the class distribution. :return: the class distribution list :rtype: ndarray """ return javabridge.get_env().get_double_array_elements(javabridge.call(self.jobject, "distribution", "()[D")) @property def margin(self): """ Returns the margin. :return: the margin :rtype: float """ return javabridge.call(self.jobject, "margin", "()D") class NumericPrediction(Prediction): """ Wrapper class for a numeric prediction. """ def __init__(self, jobject): """ Initializes the wrapper. :param jobject: the prediction to wrap :type jobject: JB_Object """ self.enforce_type(jobject, "weka.classifiers.evaluation.NumericPrediction") super(NumericPrediction, self).__init__(jobject) @property def error(self): """ Returns the error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "error", "()D") @property def prediction_intervals(self): """ Returns the prediction intervals. :return: the intervals :rtype: ndarray """ return arrays.double_matrix_to_ndarray(javabridge.call(self.jobject, "predictionIntervals", "()[[D")) class CostMatrix(JavaObject): """ Class for storing and manipulating a misclassification cost matrix. The element at position i,j in the matrix is the penalty for classifying an instance of class j as class i. Cost values can be fixed or computed on a per-instance basis (cost sensitive evaluation only) from the value of an attribute or an expression involving attribute(s). """ def __init__(self, matrx=None, num_classes=None): """ Initializes the matrix object. :param matrx: the matrix to copy :type matrx: CostMatrix or ndarray or JB_Object :param num_classes: the number of classes :type num_classes: int """ if not matrx is None: if isinstance(matrx, CostMatrix): jobject = javabridge.make_instance( "weka/classifiers/CostMatrix", "(Lweka/classifiers/CostMatrix;)V", matrx.jobject) super(CostMatrix, self).__init__(jobject) elif isinstance(matrx, ndarray): shp = matrx.shape if len(shp) != 2: raise Exception("Numpy array must be a 2-dimensional array!") rows, cols = shp if rows == cols: cmatrix = CostMatrix(num_classes=rows) for r in xrange(rows): for c in xrange(cols): cmatrix.set_element(r, c, matrx[r][c]) super(CostMatrix, self).__init__(cmatrix.jobject) else: raise Exception("Numpy array must be a square matrix!") elif isinstance(matrx, javabridge.JB_Object): super(CostMatrix, self).__init__(matrx) else: raise Exception( "Matrix must be either a CostMatrix or a 2-dimensional numpy array: " + str(type(matrx))) elif not num_classes is None: jobject = javabridge.make_instance( "weka/classifiers/CostMatrix", "(I)V", num_classes) super(CostMatrix, self).__init__(jobject) else: raise Exception("Either matrix or number of classes must be provided!") def apply_cost_matrix(self, data, rnd): """ Applies the cost matrix to the data. :param data: the data to apply to :type data: Instances :param rnd: the random number generator :type rnd: Random """ return Instances( javabridge.call( self.jobject, "applyCostMatrix", "(Lweka/core/Instances;Ljava/util/Random;)Lweka/core/Instances;", data.jobject, rnd.jobject)) def expected_costs(self, class_probs, inst=None): """ Calculates the expected misclassification cost for each possible class value, given class probability estimates. :param class_probs: the class probabilities :type class_probs: ndarray :return: the calculated costs :rtype: ndarray """ if inst is None: costs = javabridge.call( self.jobject, "expectedCosts", "([D)[D", javabridge.get_env().make_double_array(class_probs)) return javabridge.get_env().get_double_array_elements(costs) else: costs = javabridge.call( self.jobject, "expectedCosts", "([DLweka/core/Instance;)[D", javabridge.get_env().make_double_array(class_probs), inst.jobject) return javabridge.get_env().get_double_array_elements(costs) def get_cell(self, row, col): """ Returns the JB_Object at the specified location. :param row: the 0-based index of the row :type row: int :param col: the 0-based index of the column :type col: int :return: the object in that cell :rtype: JB_Object """ return javabridge.call( self.jobject, "getCell", "(II)Ljava/lang/Object;", row, col) def set_cell(self, row, col, obj): """ Sets the JB_Object at the specified location. Automatically unwraps JavaObject. :param row: the 0-based index of the row :type row: int :param col: the 0-based index of the column :type col: int :param obj: the object for that cell :type obj: object """ if isinstance(obj, JavaObject): obj = obj.jobject javabridge.call( self.jobject, "setCell", "(IILjava/lang/Object;)V", row, col, obj) def get_element(self, row, col, inst=None): """ Returns the value at the specified location. :param row: the 0-based index of the row :type row: int :param col: the 0-based index of the column :type col: int :param inst: the Instace :type inst: Instance :return: the value in that cell :rtype: float """ if inst is None: return javabridge.call( self.jobject, "getElement", "(II)D", row, col) else: return javabridge.call( self.jobject, "getElement", "(IILweka/core/Instance;)D", row, col, inst.jobject) def set_element(self, row, col, value): """ Sets the float value at the specified location. :param row: the 0-based index of the row :type row: int :param col: the 0-based index of the column :type col: int :param value: the float value for that cell :type value: float """ javabridge.call( self.jobject, "setElement", "(IID)V", row, col, value) def get_max_cost(self, class_value, inst=None): """ Gets the maximum cost for a particular class value. :param class_value: the class value to get the maximum cost for :type class_value: int :param inst: the Instance :type inst: Instance :return: the cost :rtype: float """ if inst is None: return javabridge.call( self.jobject, "getMaxCost", "(I)D", class_value) else: return javabridge.call( self.jobject, "getElement", "(ILweka/core/Instance;)D", class_value, inst.jobject) def initialize(self): """ Initializes the matrix. """ javabridge.call(self.jobject, "initialize", "()V") def normalize(self): """ Normalizes the matrix. """ javabridge.call(self.jobject, "normalize", "()V") @property def num_columns(self): """ Returns the number of columns. :return: the number of columns :rtype: int """ return javabridge.call(self.jobject, "numColumns", "()I") @property def num_rows(self): """ Returns the number of rows. :return: the number of rows :rtype: int """ return javabridge.call(self.jobject, "numRows", "()I") @property def size(self): """ Returns the number of rows/columns. :return: the number of rows/columns :rtype: int """ return javabridge.call(self.jobject, "size", "()I") def to_matlab(self): """ Returns the matrix in Matlab format. :return: the matrix as Matlab formatted string :rtype: str """ return javabridge.call(self.jobject, "toMatlab", "()Ljava/lang/String;") @classmethod def parse_matlab(cls, matlab): """ Parses the costmatrix definition in matlab format and returns a matrix. :param matlab: the matlab matrix string, eg [1 2; 3 4]. :type matlab: str :return: the generated matrix :rtype: CostMatrix """ return CostMatrix( matrx=javabridge.static_call( "weka/classifiers/CostMatrix", "parseMatlab", "(Ljava/lang/String;)Lweka/classifiers/CostMatrix;", matlab)) class Evaluation(JavaObject): """ Evaluation class for classifiers. """ def __init__(self, data, cost_matrix=None): """ Initializes an Evaluation object. :param data: the data to use to initialize the priors with :type data: Instances :param cost_matrix: the cost matrix to use for initializing :type cost_matrix: CostMatrix """ if cost_matrix is None: jobject = javabridge.make_instance( "weka/classifiers/EvaluationWrapper", "(Lweka/core/Instances;)V", data.jobject) else: jobject = javabridge.make_instance( "weka/classifiers/EvaluationWrapper", "(Lweka/core/Instances;Lweka/classifiers/CostMatrix;)V", data.jobject, cost_matrix.jobject) self.wrapper = jobject jobject = javabridge.call(jobject, "getEvaluation", "()Lweka/classifiers/Evaluation;") super(Evaluation, self).__init__(jobject) def crossvalidate_model(self, classifier, data, num_folds, rnd, output=None): """ Crossvalidates the model using the specified data, number of folds and random number generator wrapper. :param classifier: the classifier to cross-validate :type classifier: Classifier :param data: the data to evaluate on :type data: Instances :param num_folds: the number of folds :type num_folds: int :param rnd: the random number generator to use :type rnd: Random :param output: the output generator to use :type output: PredictionOutput """ if output is None: generator = [] else: generator = [output.jobject] javabridge.call( self.jobject, "crossValidateModel", "(Lweka/classifiers/Classifier;Lweka/core/Instances;ILjava/util/Random;[Ljava/lang/Object;)V", classifier.jobject, data.jobject, num_folds, rnd.jobject, generator) def evaluate_train_test_split(self, classifier, data, percentage, rnd, output=None): """ Splits the data into train and test, builds the classifier with the training data and evaluates it against the test set. :param classifier: the classifier to cross-validate :type classifier: Classifier :param data: the data to evaluate on :type data: Instances :param percentage: the percentage split to use (amount to use for training) :type percentage: double :param rnd: the random number generator to use, if None the order gets preserved :type rnd: Random :param output: the output generator to use :type output: PredictionOutput """ if not rnd is None: data.randomize(rnd) train_size = int(round(data.num_instances * percentage / 100)) test_size = data.num_instances - train_size train_inst = Instances.copy_instances(data, 0, train_size) test_inst = Instances.copy_instances(data, train_size, test_size) cls = Classifier.make_copy(classifier) cls.build_classifier(train_inst) self.test_model(cls, test_inst, output=output) def test_model(self, classifier, data, output=None): """ Evaluates the built model using the specified test data and returns the classifications. :param classifier: the trained classifier to evaluate :type classifier: Classifier :param data: the data to evaluate on :type data: Instances :param output: the output generator to use :type output: PredictionOutput :return: the classifications :rtype: ndarray """ if output is None: generator = [] else: generator = [output.jobject] cls = javabridge.call( self.jobject, "evaluateModel", "(Lweka/classifiers/Classifier;Lweka/core/Instances;[Ljava/lang/Object;)[D", classifier.jobject, data.jobject, generator) if cls is None: return None else: return javabridge.get_env().get_double_array_elements(cls) def test_model_once(self, classifier, inst): """ Evaluates the built model using the specified test instance and returns the classification. :param classifier: the classifier to cross-validate :type classifier: Classifier :param inst: the Instance to evaluate on :type inst: Instances :return: the classification :rtype: float """ return javabridge.call( self.jobject, "evaluateModelOnce", "(Lweka/classifiers/Classifier;Lweka/core/Instance;)D", classifier.jobject, inst.jobject) def summary(self, title=None, complexity=False): """ Generates a summary. :param title: optional title :type title: str :param complexity: whether to print the complexity information as well :type complexity: bool :return: the summary :rtype: str """ if title is None: return javabridge.call( self.jobject, "toSummaryString", "()Ljava/lang/String;") else: return javabridge.call( self.jobject, "toSummaryString", "(Ljava/lang/String;Z)Ljava/lang/String;", title, complexity) def class_details(self, title=None): """ Generates the class details. :param title: optional title :type title: str :return: the details :rtype: str """ if title is None: return javabridge.call( self.jobject, "toClassDetailsString", "()Ljava/lang/String;") else: return javabridge.call( self.jobject, "toClassDetailsString", "(Ljava/lang/String;)Ljava/lang/String;", title) def matrix(self, title=None): """ Generates the confusion matrix. :param title: optional title :type title: str :return: the matrix :rtype: str """ if title is None: return javabridge.call(self.jobject, "toMatrixString", "()Ljava/lang/String;") else: return javabridge.call(self.jobject, "toMatrixString", "(Ljava/lang/String;)Ljava/lang/String;", title) def area_under_prc(self, class_index): """ Returns the area under precision recall curve. :param class_index: the 0-based index of the class label :type class_index: int :return: the area :rtype: float """ return javabridge.call(self.jobject, "areaUnderPRC", "(I)D", class_index) @property def weighted_area_under_prc(self): """ Returns the weighted area under precision recall curve. :return: the weighted area :rtype: float """ return javabridge.call(self.jobject, "weightedAreaUnderPRC", "()D") def area_under_roc(self, class_index): """ Returns the area under receiver operators characteristics curve. :param class_index: the 0-based index of the class label :type class_index: int :return: the area :rtype: float """ return javabridge.call(self.jobject, "areaUnderROC", "(I)D", class_index) @property def weighted_area_under_roc(self): """ Returns the weighted area under receiver operator characteristic curve. :return: the weighted area :rtype: float """ return javabridge.call(self.jobject, "weightedAreaUnderROC", "()D") @property def avg_cost(self): """ Returns the average cost. :return: the cost :rtype: float """ return javabridge.call(self.jobject, "avgCost", "()D") @property def total_cost(self): """ Returns the total cost. :return: the cost :rtype: float """ return javabridge.call(self.jobject, "totalCost", "()D") @property def confusion_matrix(self): """ Returns the confusion matrix. :return: the matrix :rtype: ndarray """ return arrays.double_matrix_to_ndarray(javabridge.call(self.jobject, "confusionMatrix", "()[[D")) @property def correct(self): """ Returns the correct count (nominal classes). :return: the count :rtype: float """ return javabridge.call(self.jobject, "correct", "()D") @property def incorrect(self): """ Returns the incorrect count (nominal classes). :return: the count :rtype: float """ return javabridge.call(self.jobject, "incorrect", "()D") @property def unclassified(self): """ Returns the unclassified count. :return: the count :rtype: float """ return javabridge.call(self.jobject, "unclassified", "()D") @property def num_instances(self): """ Returns the number of instances that had a known class value. :return: the number of instances :rtype: float """ return javabridge.call(self.jobject, "numInstances", "()D") @property def percent_correct(self): """ Returns the percent correct (nominal classes). :return: the percentage :rtype: float """ return javabridge.call(self.jobject, "pctCorrect", "()D") @property def percent_incorrect(self): """ Returns the percent incorrect (nominal classes). :return: the percentage :rtype: float """ return javabridge.call(self.jobject, "pctIncorrect", "()D") @property def percent_unclassified(self): """ Returns the percent unclassified. :return: the percentage :rtype: float """ return javabridge.call(self.jobject, "pctUnclassified", "()D") @property def correlation_coefficient(self): """ Returns the correlation coefficient (numeric classes). :return: the coefficient :rtype: float """ return javabridge.call(self.jobject, "correlationCoefficient", "()D") def matthews_correlation_coefficient(self, class_index): """ Returns the Matthews correlation coefficient (nominal classes). :param class_index: the 0-based index of the class label :type class_index: int :return: the coefficient :rtype: float """ return javabridge.call(self.jobject, "matthewsCorrelationCoefficient", "(I)D", class_index) @property def weighted_matthews_correlation(self): """ Returns the weighted Matthews correlation (nominal classes). :return: the correlation :rtype: float """ return javabridge.call(self.jobject, "weightedMatthewsCorrelation", "()D") @property def coverage_of_test_cases_by_predicted_regions(self): """ Returns the coverage of the test cases by the predicted regions at the confidence level specified when evaluation was performed. :return: the coverage :rtype: float """ return javabridge.call(self.jobject, "coverageOfTestCasesByPredictedRegions", "()D") @property def size_of_predicted_regions(self): """ Returns the average size of the predicted regions, relative to the range of the target in the training data, at the confidence level specified when evaluation was performed. :return:the size of the regions :rtype: float """ return javabridge.call(self.jobject, "sizeOfPredictedRegions", "()D") @property def error_rate(self): """ Returns the error rate (numeric classes). :return: the rate :rtype: float """ return javabridge.call(self.jobject, "errorRate", "()D") @property def mean_absolute_error(self): """ Returns the mean absolute error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "meanAbsoluteError", "()D") @property def relative_absolute_error(self): """ Returns the relative absolute error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "relativeAbsoluteError", "()D") @property def root_mean_squared_error(self): """ Returns the root mean squared error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "rootMeanSquaredError", "()D") @property def root_relative_squared_error(self): """ Returns the root relative squared error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "rootRelativeSquaredError", "()D") @property def root_mean_prior_squared_error(self): """ Returns the root mean prior squared error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "rootMeanPriorSquaredError", "()D") @property def mean_prior_absolute_error(self): """ Returns the mean prior absolute error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "meanPriorAbsoluteError", "()D") def false_negative_rate(self, class_index): """ Returns the false negative rate. :param class_index: the 0-based index of the class label :type class_index: int :return: the rate :rtype: float """ return javabridge.call(self.jobject, "falseNegativeRate", "(I)D", class_index) @property def weighted_false_negative_rate(self): """ Returns the weighted false negative rate. :return: the rate :rtype: float """ return javabridge.call(self.jobject, "weightedFalseNegativeRate", "()D") def false_positive_rate(self, class_index): """ Returns the false positive rate. :param class_index: the 0-based index of the class label :type class_index: int :return: the rate :rtype: float """ return javabridge.call(self.jobject, "falsePositiveRate", "(I)D", class_index) @property def weighted_false_positive_rate(self): """ Returns the weighted false positive rate. :return: the rate :rtype: float """ return javabridge.call(self.jobject, "weightedFalsePositiveRate", "()D") def num_false_negatives(self, class_index): """ Returns the number of false negatives. :param class_index: the 0-based index of the class label :type class_index: int :return: the count :rtype: float """ return javabridge.call(self.jobject, "numFalseNegatives", "(I)D", class_index) def true_negative_rate(self, class_index): """ Returns the true negative rate. :param class_index: the 0-based index of the class label :type class_index: int :return: the rate :rtype: float """ return javabridge.call(self.jobject, "trueNegativeRate", "(I)D", class_index) @property def weighted_true_negative_rate(self): """ Returns the weighted true negative rate. :return: the rate :rtype: float """ return javabridge.call(self.jobject, "weightedTrueNegativeRate", "()D") def num_true_negatives(self, class_index): """ Returns the number of true negatives. :param class_index: the 0-based index of the class label :type class_index: int :return: the count :rtype: float """ return javabridge.call(self.jobject, "numTrueNegatives", "(I)D", class_index) def num_false_positives(self, class_index): """ Returns the number of false positives. :param class_index: the 0-based index of the class label :type class_index: int :return: the count :rtype: float """ return javabridge.call(self.jobject, "numFalsePositives", "(I)D", class_index) def true_positive_rate(self, class_index): """ Returns the true positive rate. :param class_index: the 0-based index of the class label :type class_index: int :return: the rate :rtype: float """ return javabridge.call(self.jobject, "truePositiveRate", "(I)D", class_index) @property def weighted_true_positive_rate(self): """ Returns the weighted true positive rate. :return: the rate :rtype: float """ return javabridge.call(self.jobject, "weightedTruePositiveRate", "()D") def num_true_positives(self, class_index): """ Returns the number of true positives. :param class_index: the 0-based index of the class label :type class_index: int :return: the count :rtype: float """ return javabridge.call(self.jobject, "numTruePositives", "(I)D", class_index) def f_measure(self, class_index): """ Returns the f measure. :param class_index: the 0-based index of the class label :type class_index: int :return: the measure :rtype: float """ return javabridge.call(self.jobject, "fMeasure", "(I)D", class_index) @property def weighted_f_measure(self): """ Returns the weighted f measure. :return: the measure :rtype: float """ return javabridge.call(self.jobject, "weightedFMeasure", "()D") @property def unweighted_macro_f_measure(self): """ Returns the unweighted macro-averaged F-measure. :return: the measure :rtype: float """ return javabridge.call(self.jobject, "unweightedMacroFmeasure", "()D") @property def unweighted_micro_f_measure(self): """ Returns the unweighted micro-averaged F-measure. :return: the measure :rtype: float """ return javabridge.call(self.jobject, "unweightedMicroFmeasure", "()D") def precision(self, class_index): """ Returns the precision. :param class_index: the 0-based index of the class label :type class_index: int :return: the precision :rtype: float """ return javabridge.call(self.jobject, "precision", "(I)D", class_index) @property def weighted_precision(self): """ Returns the weighted precision. :return: the precision :rtype: float """ return javabridge.call(self.jobject, "weightedPrecision", "()D") def recall(self, class_index): """ Returns the recall. :param class_index: the 0-based index of the class label :type class_index: int :return: the recall :rtype: float """ return javabridge.call(self.jobject, "recall", "(I)D", class_index) @property def weighted_recall(self): """ Returns the weighted recall. :return: the recall :rtype: float """ return javabridge.call(self.jobject, "weightedRecall", "()D") @property def kappa(self): """ Returns kappa. :return: kappa :rtype: float """ return javabridge.call(self.jobject, "kappa", "()D") @property def kb_information(self): """ Returns KB information. :return: the information :rtype: float """ return javabridge.call(self.jobject, "KBInformation", "()D") @property def kb_mean_information(self): """ Returns KB mean information. :return: the information :rtype: float """ return javabridge.call(self.jobject, "KBMeanInformation", "()D") @property def kb_relative_information(self): """ Returns KB relative information. :return: the information :rtype: float """ return javabridge.call(self.jobject, "KBRelativeInformation", "()D") @property def sf_entropy_gain(self): """ Returns the total SF, which is the null model entropy minus the scheme entropy. :return: the gain :rtype: float """ return javabridge.call(self.jobject, "SFEntropyGain", "()D") @property def sf_mean_entropy_gain(self): """ Returns the SF per instance, which is the null model entropy minus the scheme entropy, per instance. :return: the gain :rtype: float """ return javabridge.call(self.jobject, "SFMeanEntropyGain", "()D") @property def sf_mean_prior_entropy(self): """ Returns the entropy per instance for the null model. :return: the entropy :rtype: float """ return javabridge.call(self.jobject, "SFMeanPriorEntropy", "()D") @property def sf_mean_scheme_entropy(self): """ Returns the entropy per instance for the scheme. :return: the entropy :rtype: float """ return javabridge.call(self.jobject, "SFMeanSchemeEntropy", "()D") @property def class_priors(self): """ Returns the class priors. :return: the priors :rtype: ndarray """ return javabridge.get_env().get_double_array_elements(javabridge.call(self.jobject, "getClassPriors", "()[D")) @class_priors.setter def class_priors(self, data): """ Sets the class priors derived from the dataset. :param data: the dataset to derive the priors from :type data: Instances """ javabridge.call(self.jobject, "setClassPriors", "(Lweka/core/Instances;)V", data) @property def header(self): """ Returns the header format. :return: the header format :rtype: Instances """ return Instances(javabridge.call(self.jobject, "getHeader", "()Lweka/core/Instances;")) @property def discard_predictions(self): """ Returns whether to discard predictions (saves memory). :return: True if to discard :rtype: bool """ return javabridge.call(self.jobject, "getDiscardPredictions", "()Z") @discard_predictions.setter def discard_predictions(self, discard): """ Sets whether to discard predictions (saves memory). :param discard: True if to discard predictions :type discard: bool """ javabridge.call(self.jobject, "setDiscardPredictions", "(Z)V", discard) @property def predictions(self): """ Returns the predictions. :return: the predictions. None if not available :rtype: list """ preds = javabridge.get_collection_wrapper( javabridge.call(self.jobject, "predictions", "()Ljava/util/ArrayList;")) if self.discard_predictions: result = None else: result = [] for pred in preds: if javabridge.is_instance_of(pred, "weka/classifiers/evaluation/NominalPrediction"): result.append(NominalPrediction(pred)) elif javabridge.is_instance_of(pred, "weka/classifiers/evaluation/NumericPrediction"): result.append(NumericPrediction(pred)) else: result.append(Prediction(pred)) return result @classmethod def evaluate_model(cls, classifier, args): """ Evaluates the classifier with the given options. :param classifier: the classifier instance to use :type classifier: Classifier :param args: the command-line arguments to use :type args: list :return: the evaluation string :rtype : str """ return javabridge.static_call( "Lweka/classifiers/Evaluation;", "evaluateModel", "(Lweka/classifiers/Classifier;[Ljava/lang/String;)Ljava/lang/String;", classifier.jobject, args) class PredictionOutput(OptionHandler): """ For collecting predictions and generating output from. Must be derived from weka.classifiers.evaluation.output.prediction.AbstractOutput """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified output generator using either the classname or the supplied JB_Object. :param classname: the classname of the generator :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ if jobject is None: jobject = PredictionOutput.new_instance(classname) self.enforce_type(jobject, "weka.classifiers.evaluation.output.prediction.AbstractOutput") super(PredictionOutput, self).__init__(jobject=jobject, options=options) buf = javabridge.make_instance("java/lang/StringBuffer", "()V") javabridge.call(self.jobject, "setBuffer", "(Ljava/lang/StringBuffer;)V", buf) @property def header(self): """ Returns the header format. :return: The dataset format :rtype: Instances """ return Instances(javabridge.call(self.jobject, "getHeader", "()Lweka/core/Instances;")) @header.setter def header(self, data): """ Sets the header format. :param data: The dataset format :type data: Instances """ javabridge.call(self.jobject, "setHeader", "(Lweka/core/Instances;)V", data.jobject) def print_header(self): """ Prints the header to the buffer. """ javabridge.call(self.jobject, "printHeader", "()V") def print_footer(self): """ Prints the footer to the buffer. """ javabridge.call(self.jobject, "printFooter", "()V") def print_all(self, cls, data): """ Prints the header, classifications and footer to the buffer. :param cls: the classifier :type cls: Classifier :param data: the test data :type data: Instances """ javabridge.call( self.jobject, "print", "(Lweka/classifiers/Classifier;Lweka/core/Instances;)V", cls.jobject, data.jobject) def print_classifications(self, cls, data): """ Prints the classifications to the buffer. :param cls: the classifier :type cls: Classifier :param data: the test data :type data: Instances """ javabridge.call( self.jobject, "printClassifications", "(Lweka/classifiers/Classifier;Lweka/core/Instances;)V", cls.jobject, data.jobject) def print_classification(self, cls, inst, index): """ Prints the classification to the buffer. :param cls: the classifier :type cls: Classifier :param inst: the test instance :type inst: Instance :param index: the 0-based index of the test instance :type index: int """ javabridge.call( self.jobject, "printClassification", "(Lweka/classifiers/Classifier;Lweka/core/Instance;I)V", cls.jobject, inst.jobject, index) def buffer_content(self): """ Returns the content of the buffer as string. :return: The buffer content :rtype: str """ return javabridge.to_string(javabridge.call(self.jobject, "getBuffer", "()Ljava/lang/StringBuffer;")) def __str__(self): """ Returns the content of the buffer. :return: the current buffer content :rtype: str """ return self.buffer_content() def predictions_to_instances(data, preds): """ Turns the predictions turned into an Instances object. :param data: the original dataset format :type data: Instances :param preds: the predictions to convert :type preds: list :return: the predictions, None if no predictions present :rtype: Instances """ if len(preds) == 0: return None is_numeric = isinstance(preds[0], NumericPrediction) # create header atts = [] if is_numeric: atts.append(Attribute.create_numeric("index")) atts.append(Attribute.create_numeric("weight")) atts.append(Attribute.create_numeric("actual")) atts.append(Attribute.create_numeric("predicted")) atts.append(Attribute.create_numeric("error")) else: atts.append(Attribute.create_numeric("index")) atts.append(Attribute.create_numeric("weight")) atts.append(data.class_attribute.copy(name="actual")) atts.append(data.class_attribute.copy(name="predicted")) atts.append(Attribute.create_nominal("error", ["no", "yes"])) atts.append(Attribute.create_numeric("classification")) for i in xrange(data.class_attribute.num_values): atts.append(Attribute.create_numeric("distribution-" + data.class_attribute.value(i))) result = Instances.create_instances("Predictions", atts, len(preds)) count = 0 for pred in preds: count += 1 if is_numeric: values = array([count, pred.weight, pred.actual, pred.predicted, pred.error]) else: if pred.actual == pred.predicted: error = 0.0 else: error = 1.0 l = [count, pred.weight, pred.actual, pred.predicted, error, max(pred.distribution)] for i in xrange(data.class_attribute.num_values): l.append(pred.distribution[i]) values = array(l) inst = Instance.create_instance(values) result.add_instance(inst) return result def main(): """ Runs a classifier from the command-line. Calls JVM start/stop automatically. Use -h to see all options. """ parser = argparse.ArgumentParser( description='Performs classification/regression from the command-line. Calls JVM start/stop automatically.') parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories") parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m") parser.add_argument("-t", metavar="train", dest="train", required=True, help="Training set file") parser.add_argument("-T", metavar="test", dest="test", help="Test set file") parser.add_argument("-c", metavar="class index", dest="classindex", help="1-based class attribute index") parser.add_argument("-d", metavar="outmodel", dest="outmodel", help="model output file name") parser.add_argument("-l", metavar="inmodel", dest="inmodel", help="model input file name") parser.add_argument("-x", metavar="num folds", dest="numfolds", help="number of folds for cross-validation") parser.add_argument("-s", metavar="seed", dest="seed", help="seed value for randomization") parser.add_argument("-v", action="store_true", dest="notrainstats", help="no statistics for training") parser.add_argument("-o", action="store_true", dest="onlystats", help="only statistics, don't output model") parser.add_argument("-i", action="store_true", dest="irstats", help="output information retrieval statistics") parser.add_argument("-k", action="store_true", dest="itstats", help="output information theoretic statistics") parser.add_argument("-m", metavar="costmatrix", dest="costmatrix", help="cost matrix file") parser.add_argument("-g", metavar="graph", dest="graph", help="output file for graph (if supported)") parser.add_argument("classifier", help="classifier classname, e.g., weka.classifiers.trees.J48") parser.add_argument("option", nargs=argparse.REMAINDER, help="additional ckassifier options") parsed = parser.parse_args() jars = [] if not parsed.classpath is None: jars = parsed.classpath.split(os.pathsep) params = [] if not parsed.train is None: params.extend(["-t", parsed.train]) if not parsed.test is None: params.extend(["-T", parsed.test]) if not parsed.classindex is None: params.extend(["-c", parsed.classindex]) if not parsed.outmodel is None: params.extend(["-d", parsed.outmodel]) if not parsed.inmodel is None: params.extend(["-l", parsed.inmodel]) if not parsed.numfolds is None: params.extend(["-x", parsed.numfolds]) if not parsed.seed is None: params.extend(["-s", parsed.seed]) if parsed.notrainstats: params.append("-v") if parsed.onlystats: params.append("-o") if parsed.irstats: params.append("-i") if parsed.itstats: params.append("-k") if not parsed.costmatrix is None: params.extend(["-m", parsed.costmatrix]) if not parsed.graph is None: params.extend(["-g", parsed.graph]) jvm.start(jars, max_heap_size=parsed.heap, packages=True) logger.debug("Commandline: " + wutils.join_options(sys.argv[1:])) try: classifier = Classifier(classname=parsed.classifier) if len(parsed.option) > 0: classifier.options = parsed.option print(Evaluation.evaluate_model(classifier, params)) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main() except Exception, ex: print(ex) python-weka-wrapper-0.2.2/python/weka/associations.py0000644017267001726700000000760512452314622024421 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # associations.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging import os import sys import argparse import weka.core.jvm as jvm import weka.core.utils as utils import weka.core.converters as converters from weka.core.classes import OptionHandler from weka.core.capabilities import Capabilities # logging setup logger = logging.getLogger("weka.associations") class Associator(OptionHandler): """ Wrapper class for associators. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified associator using either the classname or the supplied JB_Object. :param classname: the classname of the associator :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ if jobject is None: jobject = Associator.new_instance(classname) self.enforce_type(jobject, "weka.associations.Associator") super(Associator, self).__init__(jobject=jobject, options=options) @property def capabilities(self): """ Returns the capabilities of the associator. :return: the capabilities :rtype: Capabilities """ return Capabilities(javabridge.call(self.jobject, "getCapabilities", "()Lweka/core/Capabilities;")) def build_associations(self, data): """ Builds the associator with the data. :param data: the data to train the associator with :type data: Instances """ javabridge.call(self.jobject, "buildAssociations", "(Lweka/core/Instances;)V", data.jobject) def main(): """ Runs a associator from the command-line. Calls JVM start/stop automatically. Use -h to see all options. """ parser = argparse.ArgumentParser( description='Executes an associator from the command-line. Calls JVM start/stop automatically.') parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories") parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m") parser.add_argument("-t", metavar="train", dest="train", required=True, help="training set file") parser.add_argument("associator", help="associator classname, e.g., weka.associations.Apriori") parser.add_argument("option", nargs=argparse.REMAINDER, help="additional associator options") parsed = parser.parse_args() jars = [] if not parsed.classpath is None: jars = parsed.classpath.split(os.pathsep) jvm.start(jars, max_heap_size=parsed.heap, packages=True) logger.debug("Commandline: " + utils.join_options(sys.argv[1:])) try: associator = Associator(classname=parsed.associator) if len(parsed.option) > 0: associator.options = parsed.option loader = converters.loader_for_file(parsed.train) data = loader.load_file(parsed.train) associator.build_associations(data) print(str(associator)) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main() except Exception, ex: print(ex) python-weka-wrapper-0.2.2/python/weka/clusterers.py0000644017267001726700000003511712452364015024115 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # clusterers.py # Copyright (C) 2014-2015 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging import os import sys import argparse import weka.core.jvm as jvm import weka.core.utils as utils from weka.core.classes import JavaObject from weka.core.classes import OptionHandler from weka.core.classes import Random from weka.core.capabilities import Capabilities from weka.filters import Filter # logging setup logger = logging.getLogger("weka.clusterers") class Clusterer(OptionHandler): """ Wrapper class for clusterers. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified clusterer using either the classname or the supplied JB_Object. :param classname: the classname of the clusterer :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to use :type options: list """ if jobject is None: jobject = Clusterer.new_instance(classname) self.is_updateable = self.check_type(jobject, "weka.clusterers.UpdateableClusterer") self.is_drawable = self.check_type(jobject, "weka.core.Drawable") self.enforce_type(jobject, "weka.clusterers.Clusterer") super(Clusterer, self).__init__(jobject=jobject, options=options) self.__cluster = javabridge.make_call(self.jobject, "clusterInstance", "(Lweka/core/Instance;)I") self.__distribution = javabridge.make_call(self.jobject, "distributionForInstance", "(Lweka/core/Instance;)[D") @property def capabilities(self): """ Returns the capabilities of the clusterer. :return: the capabilities :rtype: Capabilities """ return Capabilities(javabridge.call(self.jobject, "getCapabilities", "()Lweka/core/Capabilities;")) def build_clusterer(self, data): """ Builds the clusterer with the data. :param data: the data to use for training the clusterer :type data: Instances """ javabridge.call(self.jobject, "buildClusterer", "(Lweka/core/Instances;)V", data.jobject) def update_clusterer(self, inst): """ Updates the clusterer with the instance. :param inst: the Instance to update the clusterer with :type inst: Instance """ if self.is_updateable: javabridge.call(self.jobject, "updateClusterer", "(Lweka/core/Instance;)V", inst.jobject) else: logger.critical(utils.get_classname(self.jobject) + " is not updateable!") def update_finished(self): """ Signals the clusterer that updating with new data has finished. """ if self.is_updateable: javabridge.call(self.jobject, "updateFinished", "()V") else: logger.critical(utils.get_classname(self.jobject) + " is not updateable!") def cluster_instance(self, inst): """ Peforms a prediction. :param inst: the instance to determine the cluster for :type inst: Instance :return: the clustering result :rtype: float """ return self.__cluster(inst.jobject) def distribution_for_instance(self, inst): """ Peforms a prediction, returning the cluster distribution. :param inst: the Instance to get the cluster distribution for :type inst: Instance :return: the cluster distribution :rtype: float[] """ pred = self.__distribution(inst.jobject) return javabridge.get_env().get_double_array_elements(pred) @property def number_of_clusters(self): """ Returns the number of clusters found. :return: the number fo clusters :rtype: int """ return javabridge.call(self.jobject, "numberOfClusters", "()I") @property def graph_type(self): """ Returns the graph type if classifier implements weka.core.Drawable, otherwise -1. :return: the type :rtype: int """ if self.is_drawable: return javabridge.call(self.jobject, "graphType", "()I") else: return -1 @property def graph(self): """ Returns the graph if classifier implements weka.core.Drawable, otherwise None. :return: the graph or None if not available :rtype: str """ if self.is_drawable: return javabridge.call(self.jobject, "graph", "()Ljava/lang/String;") else: return None class SingleClustererEnhancer(Clusterer): """ Wrapper class for clusterers that use a single base clusterer. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified clusterer using either the classname or the supplied JB_Object. :param classname: the classname of the clusterer :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to use :type options: list """ if jobject is None: jobject = Clusterer.new_instance(classname) self.enforce_type(jobject, "weka.clusterers.SingleClustererEnhancer") super(SingleClustererEnhancer, self).__init__(classname=classname, jobject=jobject, options=options) @property def clusterer(self): """ Returns the base clusterer. :return: the clusterer :rtype: Clusterer """ return Clusterer(jobject=javabridge.call(self.jobject, "getClusterer", "()Lweka/clusterers/Clusterer;")) @clusterer.setter def clusterer(self, clusterer): """ Sets the base clusterer. :param clusterer: the base clusterer to use :type clusterer: Clusterer """ javabridge.call(self.jobject, "setClusterer", "(Lweka/clusterers/Clusterer;)V", clusterer.jobject) class FilteredClusterer(SingleClustererEnhancer): """ Wrapper class for the filtered clusterer. """ def __init__(self, jobject=None, options=None): """ Initializes the specified clusterer using either the classname or the supplied JB_Object. :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to use :type options: list """ classname = "weka.clusterers.FilteredClusterer" if jobject is None: jobject = Clusterer.new_instance(classname) self.enforce_type(jobject, classname) super(FilteredClusterer, self).__init__(classname=classname, jobject=jobject, options=options) @property def filter(self): """ Returns the filter. :return: the filter :rtype: Filter """ return Filter(jobject=javabridge.call(self.jobject, "getFilter", "()Lweka/filters/Filter;")) @filter.setter def filter(self, filtr): """ Sets the filter. :param filtr: the filter to use :type filtr: Filter """ javabridge.call(self.jobject, "setFilter", "(Lweka/filters/Filter;)V", filtr.jobject) class ClusterEvaluation(JavaObject): """ Evaluation class for clusterers. """ def __init__(self): """ Initializes a ClusterEvaluation object. """ super(ClusterEvaluation, self).__init__(ClusterEvaluation.new_instance("weka.clusterers.ClusterEvaluation")) def set_model(self, clusterer): """ Sets the built clusterer to evaluate. :param clusterer: the clusterer to evaluate :type clusterer: Clusterer """ javabridge.call(self.jobject, "setClusterer", "(Lweka/clusterers/Clusterer;)V", clusterer.jobject) def test_model(self, test): """ Evaluates the currently set clusterer on the test set. :param test: the test set to use for evaluating :type test: Instances """ javabridge.call(self.jobject, "evaluateClusterer", "(Lweka/core/Instances;)V", test.jobject) @property def cluster_results(self): """ The cluster results as string. :return: the results string :rtype: str """ return javabridge.call(self.jobject, "clusterResultsToString", "()Ljava/lang/String;") @property def cluster_assignments(self): """ Return an array of cluster assignments corresponding to the most recent set of instances clustered. :return: the cluster assignments :rtype: ndarray """ array = javabridge.call(self.jobject, "getClusterAssignments", "()[D") if array is None: return None else: return javabridge.get_env().get_double_array_elements(array) @property def num_clusters(self): """ Returns the number of clusters. :return: the number of clusters :rtype: int """ return javabridge.call(self.jobject, "getNumClusters", "()I") @property def log_likelihood(self): """ Returns the log likelihood. :return: the log likelihood :rtype: float """ return javabridge.call(self.jobject, "getLogLikelihood", "()D") @property def classes_to_clusters(self): """ Return the array (ordered by cluster number) of minimum error class to cluster mappings.. :return: the mappings :rtype: ndarray """ array = javabridge.call(self.jobject, "getClassesToClusters", "()[I") if array is None: return None else: return javabridge.get_env().get_int_array_elements(array) @classmethod def evaluate_clusterer(cls, clusterer, args): """ Evaluates the clusterer with the given options. :param clusterer: the clusterer instance to evaluate :type clusterer: Clusterer :param args: the command-line arguments :type args: list :return: the evaluation result :rtype: str """ return javabridge.static_call( "Lweka/clusterers/ClusterEvaluation;", "evaluateClusterer", "(Lweka/clusterers/Clusterer;[Ljava/lang/String;)Ljava/lang/String;", clusterer.jobject, args) @classmethod def crossvalidate_model(cls, clusterer, data, num_folds, rnd): """ Cross-validates the clusterer and returns the loglikelihood. :param clusterer: the clusterer instance to evaluate :type clusterer: Clusterer :param data: the data to evaluate on :type data: Instances :param num_folds: the number of folds :type num_folds: int :param rnd: the random number generator to use :type rnd: Random :return: the cross-validated loglikelihood :rtype: float """ return javabridge.static_call( "Lweka/clusterers/ClusterEvaluation;", "crossValidateModel", "(Lweka/clusterers/DensityBasedClusterer;Lweka/core/Instances;ILjava/util/Random;)D", clusterer.jobject, data.jobject, num_folds, rnd.jobject) def main(): """ Runs a clusterer from the command-line. Calls JVM start/stop automatically. Use -h to see all options. """ parser = argparse.ArgumentParser( description='Performs clustering from the command-line. Calls JVM start/stop automatically.') parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories") parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m") parser.add_argument("-t", metavar="train", dest="train", required=True, help="training set file") parser.add_argument("-T", metavar="test", dest="test", help="test set file") parser.add_argument("-d", metavar="outmodel", dest="outmodel", help="model output file name") parser.add_argument("-l", metavar="inmodel", dest="inmodel", help="model input file name") parser.add_argument("-p", metavar="attributes", dest="attributes", help="attribute range") parser.add_argument("-x", metavar="num folds", dest="numfolds", help="number of folds") parser.add_argument("-s", metavar="seed", dest="seed", help="seed value for randomization") parser.add_argument("-c", metavar="class index", dest="classindex", help="1-based class attribute index") parser.add_argument("-g", metavar="graph", dest="graph", help="graph output file (if supported)") parser.add_argument("clusterer", help="clusterer classname, e.g., weka.clusterers.SimpleKMeans") parser.add_argument("option", nargs=argparse.REMAINDER, help="additional clusterer options") parsed = parser.parse_args() jars = [] if not parsed.classpath is None: jars = parsed.classpath.split(os.pathsep) params = [] if not parsed.train is None: params.extend(["-t", parsed.train]) if not parsed.test is None: params.extend(["-T", parsed.test]) if not parsed.outmodel is None: params.extend(["-d", parsed.outmodel]) if not parsed.inmodel is None: params.extend(["-l", parsed.inmodel]) if not parsed.attributes is None: params.extend(["-p", parsed.attributes]) if not parsed.numfolds is None: params.extend(["-x", parsed.numfolds]) if not parsed.seed is None: params.extend(["-s", parsed.seed]) if not parsed.classindex is None: params.extend(["-c", parsed.classindex]) if not parsed.graph is None: params.extend(["-g", parsed.graph]) jvm.start(jars, max_heap_size=parsed.heap, packages=True) logger.debug("Commandline: " + utils.join_options(sys.argv[1:])) try: clusterer = Clusterer(classname=parsed.clusterer) if len(parsed.option) > 0: clusterer.options = parsed.option print(ClusterEvaluation.evaluate_clusterer(clusterer, params)) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main() except Exception, ex: print(ex) python-weka-wrapper-0.2.2/python/weka/attribute_selection.py0000644017267001726700000003041012446346264025772 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # attribute_selection.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging import argparse import os import sys import weka.core.jvm as jvm import weka.core.utils as utils import weka.core.types as arrays from weka.core.classes import JavaObject from weka.core.classes import OptionHandler from weka.core.capabilities import Capabilities from weka.core.dataset import Instances, Instance # logging setup logger = logging.getLogger("weka.attribute_selection") class ASSearch(OptionHandler): """ Wrapper class for attribute selection search algorithm. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified search algorithm using either the classname or the supplied JB_Object. :param classname: the classname of the search algorithms :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the commandline options to use :type options: list """ if jobject is None: jobject = ASSearch.new_instance(classname) self.enforce_type(jobject, "weka.attributeSelection.ASSearch") super(ASSearch, self).__init__(jobject=jobject, options=options) def search(self, evaluation, data): """ Performs the search and returns the indices of the selected attributes. :param evaluation: the evaluation algorithm to use :type evaluation: ASEvaluation :param data: the data to use :type data: Instances :return: the selected attributes (0-based indices) :rtype: ndarray """ array = javabridge.call( self.jobject, "search", "(Lweka/attributeSelection/ASEvaluation;Lweka/core/Instances;)[I", evaluation.jobject, data.jobject) if array is None: return None else: javabridge.get_env().get_int_array_elements(array) class ASEvaluation(OptionHandler): """ Wrapper class for attribute selection evaluation algorithm. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified search algorithm using either the classname or the supplied JB_Object. :param classname: the classname of the search algorithms :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ if jobject is None: jobject = ASEvaluation.new_instance(classname) self.enforce_type(jobject, "weka.attributeSelection.ASEvaluation") super(ASEvaluation, self).__init__(jobject=jobject, options=options) @property def capabilities(self): """ Returns the capabilities of the classifier. :return: the capabilities :rtype: Capabilities """ return Capabilities(javabridge.call(self.jobject, "getCapabilities", "()Lweka/core/Capabilities;")) def build_evaluator(self, data): """ Builds the evaluator with the data. :param data: the data to use :type data: Instances """ javabridge.call(self.jobject, "buildEvaluator", "(Lweka/core/Instances;)V", data.jobject) def post_process(self, indices): """ Post-processes the evaluator with the selected attribute indices. :param indices: the attribute indices list to use :type indices: ndarray :return: the processed indices :rtype: ndarray """ array = javabridge.call(self.jobject, "postProcess", "([I)[I", indices) if array is None: return None else: return javabridge.get_env().get_int_array_elements(array) class AttributeSelection(JavaObject): """ Performs attribute selection using search and evaluation algorithms. """ def __init__(self): """ Initializes the attribute selection. """ jobject = AttributeSelection.new_instance("weka.attributeSelection.AttributeSelection") super(AttributeSelection, self).__init__(jobject) def evaluator(self, evaluator): """ Sets the evaluator to use. :param evaluator: the evaluator to use. :type evaluator: ASEvaluation """ javabridge.call(self.jobject, "setEvaluator", "(Lweka/attributeSelection/ASEvaluation;)V", evaluator.jobject) def search(self, search): """ Sets the search algorithm to use. :param search: the search algorithm :type search: ASSearch """ javabridge.call(self.jobject, "setSearch", "(Lweka/attributeSelection/ASSearch;)V", search.jobject) def folds(self, folds): """ Sets the number of folds to use for cross-validation. :param folds: the number of folds :type folds: int """ javabridge.call(self.jobject, "setFolds", "(I)V", folds) def ranking(self, ranking): """ Sets whether to perform a ranking, if possible. :param ranking: whether to perform a ranking :type ranking: bool """ javabridge.call(self.jobject, "setRanking", "(Z)V", ranking) def seed(self, seed): """ Sets the seed for cross-validation. :param seed: the seed value :type seed: int """ javabridge.call(self.jobject, "setSeed", "(I)V", seed) def crossvalidation(self, crossvalidation): """ Sets whether to perform cross-validation. :param crossvalidation: whether to perform cross-validation :type crossvalidation: bool """ javabridge.call(self.jobject, "setXval", "(Z)V", crossvalidation) def select_attributes(self, instances): """ Performs attribute selection on the given dataset. :param instances: the data to process :type instances; Instances """ javabridge.call(self.jobject, "SelectAttributes", "(Lweka/core/Instances;)V", instances.jobject) def select_attributes_cv_split(self, instances): """ Performs attribute selection on the given cross-validation split. :param instances: the data to process :type instances: Instances """ javabridge.call(self.jobject, "selectAttributesCVSplit", "(Lweka/core/Instances;)V", instances.jobject) @property def selected_attributes(self): """ Returns the selected attributes from the last run. :return: the Numpy array of 0-based indices :rtype: ndarray """ array = javabridge.call(self.jobject, "selectedAttributes", "()[I") if array is None: return None else: return javabridge.get_env().get_int_array_elements(array) @property def results_string(self): """ Generates a results string from the last attribute selection. :return: the results string :rtype: str """ return javabridge.call(self.jobject, "toResultsString", "()Ljava/lang/String;") @property def cv_results(self): """ Generates a results string from the last cross-validation attribute selection. :return: the results string :rtype: str """ return javabridge.call(self.jobject, "CVResultsString", "()Ljava/lang/String;") @property def number_attributes_selected(self): """ Returns the number of attributes that were selected. :return: the number of attributes :rtype: int """ return javabridge.call(self.jobject, "numberAttributesSelected", "()I") @property def ranked_attributes(self): """ Returns the matrix of ranked attributes from the last run. :return: the Numpy matrix :rtype: ndarray """ matrix = javabridge.call(self.jobject, "rankedAttributes", "()[[D") if matrix is None: return None else: return arrays.double_matrix_to_ndarray(matrix) def reduce_dimensionality(self, data): """ Reduces the dimensionality of the provided Instance or Instances object. :param data: the data to process :type data: Instances :return: the reduced dataset :rtype: Instances """ if type(data) is Instance: return Instance( javabridge.call( self.jobject, "reduceDimensionality", "(Lweka/core/Instance;)Lweka/core/Instance;", data.jobject)) else: return Instances( javabridge.call( self.jobject, "reduceDimensionality", "(Lweka/core/Instances;)Lweka/core/Instances;", data.jobject)) @classmethod def attribute_selection(cls, evaluator, args): """ Performs attribute selection using the given attribute evaluator and options. :param evaluator: the evaluator to use :type evaluator: ASEvaluation :param args: the command-line args for the attribute selection :type args: list :return: the results string :rtype; str """ return javabridge.static_call( "Lweka/attributeSelection/AttributeSelection;", "SelectAttributes", "(Lweka/attributeSelection/ASEvaluation;[Ljava/lang/String;)Ljava/lang/String;", evaluator.jobject, args) def main(): """ Runs attribute selection from the command-line. Calls JVM start/stop automatically. Use -h to see all options. """ parser = argparse.ArgumentParser( description='Performs attribute selection from the command-line. Calls JVM start/stop automatically.') parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories") parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m") parser.add_argument("-i", metavar="input", dest="input", required=True, help="input file") parser.add_argument("-c", metavar="class index", dest="classindex", help="1-based class attribute index") parser.add_argument("-s", metavar="search", dest="search", help="search method, classname and options") parser.add_argument("-x", metavar="num folds", dest="numfolds", help="number of folds") parser.add_argument("-n", metavar="seed", dest="seed", help="the seed value for randomization") parser.add_argument("evaluator", help="evaluator classname, e.g., weka.attributeSelection.CfsSubsetEval") parser.add_argument("option", nargs=argparse.REMAINDER, help="additional evaluator options") parsed = parser.parse_args() jars = [] if not parsed.classpath is None: jars = parsed.classpath.split(os.pathsep) params = [] if not parsed.input is None: params.extend(["-i", parsed.input]) if not parsed.classindex is None: params.extend(["-c", parsed.classindex]) if not parsed.search is None: params.extend(["-s", parsed.search]) if not parsed.numfolds is None: params.extend(["-x", parsed.numfolds]) if not parsed.seed is None: params.extend(["-n", parsed.seed]) jvm.start(jars, max_heap_size=parsed.heap, packages=True) logger.debug("Commandline: " + utils.join_options(sys.argv[1:])) try: evaluation = ASEvaluation(classname=parsed.evaluator) if len(parsed.option) > 0: evaluation.options = parsed.option print(AttributeSelection.attribute_selection(evaluation, params)) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main() except Exception, ex: print(ex) python-weka-wrapper-0.2.2/python/weka/lib/0000755017267001726700000000000012452374314022112 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.2.2/python/weka/lib/python-weka-wrapper.jar0000644017267001726700000000573412424564746026556 0ustar fracpetefracpete00000000000000PKÇu_E META-INF/þÊPKPKÇu_EMETA-INF/MANIFEST.MFóMÌËLK-.Ñ K-*ÎÌϳR0Ô3àår.JM,IMÑuª ˜ëÄ›˜*hø%&ç¤*8çä%–•kòrñrPKXECDPK Çu_Eweka/PK Çu_Eweka/classifiers/PKÇu_E#weka/classifiers/KernelHelper.classÍVisE~z¯ÙL¹ À&$,—.×&`Â!D‘Éî$L²;³ÌN8Ä AKD¿XåY¨¤TDåÃ¥¤¬ÒÂ*«üúÉ¿`YƧw³dsp}#[éî·ß£Ÿ÷è·ç÷ÿ~¼ `)ÞSQ†F9lP±M¥Ø„Í*¶`«¶©ˆ¡YA‹‚í%ØgƒhUц*J°KE v+Ø#…ž boû´«˜ˆFÏ«¨D£TzAÁ~SÑÄ‹r> BG‡\ŃHH#†$:ƒè’ÄA&ºƒè‘DRAJÅ|iÐR–³-XmZ¦»VÀ®Þ-àk´†@YÌ´Œ–ÞT‡áìÔ;’Ü™Ðe¸Û Ç2’;;m8î1eáX·~X$u«+²½£Ûˆ»õÕù­C·2‘‚è#wÌ´k;õãÚ\=ÞÓ¬§s–鳂´‚C F†Ô3#ªë }%™(¦1dbGŒ=OꙌÙiN&ÒÙkÅ]Ó&¶Lo:m;înÊÙN$o…F™ Úí²»qL'Õ0#›ÒMK`r¸½È^›ë˜VW½Œ¼ºñhÜHçLh³{¸ÑdæBŸ·±ÙH2‹¤²†…¨Õ« WÃaa5Å1ÆRÃK8®áeWðŠ†Wá D¯ÀÄ!w)xMÃë8!° I'´DȵCiÇŽ™ŒœsÙ %î&;Uð††“8¥áM 8‚Åå#éá4Î0ÉC6™ÖPOHtØ~WñþÒ‡ö©µ¡©àÖ¬û(µ5o×ð–toÊÈ 5ôšÉ„áøÕººµ! gqNÁy pQÃÛ¸( ±nÁ­£ÀÓX)¥. ss5Ö(xGÃe¼K…!/¥Â*Ч9÷‡ç]ÓFɸŽad"[—¯˜9ŠY\<äß÷vÒžç7pÜbu²I„Úx«ƒÌM£<–6ÂÕE%žÛ¬/Ä4oa‹å:v&ËŽ@)U‡Î ‡G)ë)IšœLÅÑ`ˆ`n¸úÁˆÇS{cºF³á´3†ávŒÎ$Fò\Ù·(ßj艂øÔ{ÉDÝ^ÇÚy,m +ù¶c×H±Ý]¯ÌhÚ„hZ.‹ÍÐSõ…4 ßPÒ’JZ#bQ)KçåÙ`w:zœGLë°ÝÃŪ1úXû=ûwñÁÚ½l"=6,ºW7Ö飶ï ÕËF$”ž0@-zŠ°&…GkÊrríüZ¦eß}ç+ÞvŒÈ.×LÒø8×n´S)ÝJÈWL`þ½Ÿ©âC1‡dä_BvXŽu¤frœý57!¾çB`Ñ øŽ–ȶ–³á! ±š,<ýð6×þŸ@K]Ô_忽"à]¡T*•+¨¯òW*K£Áª`þ;˜/çÀoôazn™…õUù&"x%UÁXJN)¢oà×>LŠúEìÔŠÒ,´*ã~G´c?÷äà5aǤVAE”T=ý[ÍÕþÖòÛd¶c=Zñ v‘×Îo”ýül9@Ír»±6¶a ­lF`3T°TÁ2Ë<þ Fà_„¸÷¦ Àß0 ðtO~ BÁŠr¢ccŒëâÁ¸Ž«éÇø;P|}ðy¯qÃSß]9~xJ×ó]–]rPû ¤‡Þ5R¿¥îjëJ´ßO(Ûë]Ø–Eùßš>TDý2^ ñšqVJ1óîÆki Aª“®u‘2³n„ÐC¹4%SX‹É¶±œO¯„5ž2ò^׋‚›ãi”­~èex‰Xš ÐæÚ;XPË·ÔÕx “†LoEÔ'1VHŒ¾BNKY}¡»k˜Ià©“ÄxŠÜÓ(ÇÊ\ ÔYââUÿ˜åþ ËéS\Å\ÇgøŸão|!‚¸*æ¡OlÀ—"†¯D¾gpM\Å7â\â[¶°”ä%l)ò7üPKYkH PKÇu_E(weka/classifiers/EvaluationWrapper.class…’]OA†ßi Cë"壀B¥Ti·¥eAåB«øA Ñ´hR¢ñÊL—‘,´»ÍîQ/ü9ÞªQšhâðG©g¶Å–ØàÅÎì¼gæ=Ïœ9?}ûà:ÖcÐä¸C Q\@Šc1Š4®ŽàZ KÈÄ0„¬ ë9Ž<ƒÖx¹u$ê-á[ŽÍ,¿–‡Â0ëÂó¬W–t=£.1 ß±lËß`˜Õ»;Wl϶)½RîCdÓÙ“ ceË–;­FMº»¢V'e´ê ó°"šÁ: X&B†õÁfÿ²l:ž_¾kS&ŽyîK¿ÿ zî?WˆU–kÊmK!M÷BÏ]ÑlJwå@ c(2Ì㤶Ä5Œâ"ä:cÔ…½ol›²©â+ ¬2d·åÚKùNJÏuë­LõœRNí@šþmŽ5žñ††›(*û†ô9]`†x/ý“ÀŠˆÔsÐ}zeëêõú̪o<_6( ]Ê’(Ë1žº–íW}WŠFéôògeÞT«:½HB/÷YR*{?h“±fg?µÄ®+L‰EêX:™:H••þÂôOU¦qœVïHӜɷÁòßz±ÜFø+"¨|Æð?ÁHáÑ<#ñSàÇ$µ|t.uRó¤¯R¤€)1¤è©–°Fè ýVÇGŒcz<™é‚¼'ËÍÙH¡X‡d甤x–dœr%¹Ej‰ô¹K‰6Ä=ªÂ}dð0 ™V$SwH8fÿÂ\Âå.L’fFóPþ "ƒò©Ãø˜Æ9šC˜ÿPKÇNcY'PKÇu_E META-INF/þÊPKÇu_EXECD=META-INF/MANIFEST.MFPK Çu_EÂweka/PK Çu_Eåweka/classifiers/PKÇu_EYkH #weka/classifiers/KernelHelper.classPKÇu_EÇNcY'(weka/classifiers/EvaluationWrapper.classPK–0 python-weka-wrapper-0.2.2/python/weka/lib/python-weka-wrapper-src.jar0000644017267001726700000000611412424564746027334 0ustar fracpetefracpete00000000000000PKÇu_E META-INF/þÊPKPKÇu_EMETA-INF/MANIFEST.MFóMÌËLK-.Ñ K-*ÎÌϳR0Ô3àår.JM,IMÑuª ˜ëÄ›˜*hø%&ç¤*8çä%–•kòrñrPKXECDPK 蚎Dweka/PK Š]_Eweka/classifiers/PKDu_E"weka/classifiers/KernelHelper.javaíWMsÛ6=K¿b›K©Ô¡’6‡ŽU§qT+QãØInÆ“ú‘K 1pPª&ñï %Ú¢l§“ô” %»ûñv·á1Lf\C®dªØèo¢AËÄ,™Â}XÉ"&@a̵Q|Zn€‰¸+ÌeÌ“•Å¡±BĨÀÌ ª¹™¸—×'çð*–ÁY1ÍxÇ ÆhÃB pG‰×%*cŒ†ñLW‰_Pc5E—Å0c ¤GȃHæ«û›gAX&EêÒ$ãM!)¸aBš=Ðäo3còýnw¹\†©(B©ÒnæAt÷… ¨Ûnw]ToQ ÌÞ`–£ ?²³ƒ}ŠGñtf èwàç§ÏžCX”#Q1HªÔŸtNB, ¥0ïxÜœEW,EXâ £ŒiÍNèµÛÔ © ØeÂ)2¡ÃWôŠDöæ†Â(©sŒŒTMógŠx¢ÌêÔ‘âù–UÆD*L2Bß!1#ÞÄp;º0)Dd©«Ãñ»ÓÞÃ̦±ÔEnMþr™„¾â_î7z5¸ÏÕŒuøçó_o™ÃsC\ìÙ¶»¾ûŽƒóv”½rØk¶¾dL¹¾Ÿ=¤ï¹çª¬³ >µÛnY àšB í¸$\iÓ)׶dv ­¤ §mëÀ9zï—9³ûÍÔ,ÀHHѸ‘ÛP‰’óÒU¹•›¬ö@´Ëð¤Œ%jñ£ñB•B—že–ÚÐöÁ6m>ùj.8õ„Ü¡RPƒ[«¥P™é¹ùJ­V‹;m4;}¸lÙ´ŸïÛ“G”•îáaáÀ%X7jU`×2©ë-¤<ª0 ݾ»‚N§Wú¹ÅÉÏúÛùíɺ2¶ êeAö=”-O‹zöÕ"¾WÜ WnПE>†µÉY¼eÑi·€˜) öÚ¶&g“‹·¼˜¬r´áºœÃAIc/1]­ ­gG¦ Ùý».3õ¿þ1Í 8ú'Bw.vÖeoh 1+mp¢Ra®¸0™ HktLÉi͵ް;Þ”zÿѺÖè}džvâ ©«6\׉áÄ°¡Ýõ •ög]iXÎÐÿV3´è‚ÇH©‘Ý%XY"°;ò:¬ð!‚ì ·”© ´"¬úEnÉu‡§Rf6 ò¹W‚åŠÁ¶\Ñ%‘¶ 3F£k[ȃRÕ7÷¦Ä^™jåpÍÂûì.Ni¶¤âXl]D–t=Êî«®ò­Õd¯j¢‡­JTºÜÜš¶./;éEÕj-­l›6¡„eº>a]i¸¹ ÞΪљU-YëÇoa~±šºoì½r>äb!¯0pÙ \‚ÏþÃå'Ÿóµµ\‡iK]i©Ru³’[wëÕ6Ç/àÔÙÚ)Ì›»Æ.º™5_71¾ì˜¼ëtÜŠÉ:!9¥+­ØÁ±’EiŪ®ù‰ÿ@)Úcãk_ƒPv)€çE&ÁÛR/ÖcÞ^v¾ •ÒoI¥Ä5—)Ýv²U—˜Ju‹n{sú͸@7O€§‚®—ñN,$.‹"ÓWžH?\:¿ñLÉ¥†Mê©èyà*¹¾øV)ö×W^°·ØdêzëD·s2_O”Å¥oÃMqÿOž¼€Gð“u«]pìß6ÇõU§ÉÙL>ÊßÄö¡C w”ÍtÎînÙ÷å=¦ònN&tÒf—ñ¡èºç^µ«õP¶ NŸCßkþÖœ¾ô¾üüº}ÝþPK†®„̵PK/[¶D'weka/classifiers/EvaluationWrapper.javaÕT]oÛ6}÷¯8È“Òúñ”lC½Àn ¤‰a;ò4ÐÒ•ÅV"’²êù､$Ûi¶¶Ø°‡½¤xïáù¸t|>À9Ö¹´¨ŒÞQ‚—™!‚Õ™k„¡ ìuD(J¥uFnjGB¥±6(u*³½ÇáoµJÉÀåG¦´ÐYؼ½¹Ã[RdDE½)d‚k™²ÁWû/6§›€ã;fžÃªã€™f`á¤VcäsƒË{¼êïèÇÐƃ …óÌ tåûFLwB¸ckÄe%ÿ¨2…T;×+Ê’56²(°!Ô–²º{.Æý|ýîönÉÍî'ËåäfýpÉÅ.×|J;j¡dY’‘Y—Ê홾Gx?]^½ã–ÉóëùúE`6_ßLW+Ìn—˜`1Y®çWwד%wËÅíj+ò´È|Çâ,¤Ä6¦ä„,l/üƒµÌ®H‘‹qÀ ÉsHtµÿqxDZmƒL.>Éäæ”vcX&ùkî\uÇMÓD[UGÚl㢱ñïžP<ÄÕt'Š:d}oDU‘‰>ˆð'WLÊÈmî0¼áå//^󘈤"žÇaÖ¯8¤mÉ2‘jÇ:ÊQ ^‰ä£Øú(¢¤ÖÊLò \‰6®;aŸ¢¹²N¨„üa|Xu\:©z{Î\ntc1ý”Pµ3_ÄÃÑO¢ÎÔ‰Ó¦wþ¨Àú‹Ÿ¡_µ¾··?s_€™†ûšð1å‘ëË 7(q‘G‚OÈñŽ+Ž@(ÿ. # filters.py # Copyright (C) 2014-2015 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging import os import sys import argparse import weka.core.jvm as jvm import weka.core.utils as utils from weka.core.classes import OptionHandler from weka.core.capabilities import Capabilities from weka.core.converters import Loader from weka.core.converters import Saver from weka.core.dataset import Instances from weka.core.dataset import Instance # logging setup logger = logging.getLogger("weka.filters") class Filter(OptionHandler): """ Wrapper class for filters. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified filter using either the classname or the supplied JB_Object. :param classname: the classname of the filter :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object :param options: the list of commandline options to set :type options: list """ if jobject is None: jobject = Filter.new_instance(classname) self.enforce_type(jobject, "weka.filters.Filter") super(Filter, self).__init__(jobject=jobject, options=options) self.__input = javabridge.make_call(self.jobject, "input", "(Lweka/core/Instance;)Z") self.__output = javabridge.make_call(self.jobject, "output", "()Lweka/core/Instance;") self.__outputformat = javabridge.make_call(self.jobject, "getOutputFormat", "()Lweka/core/Instances;") def capabilities(self): """ Returns the capabilities of the filter. :return: the capabilities :rtype: Capabilities """ return Capabilities(javabridge.call(self.jobject, "getCapabilities", "()Lweka/core/Capabilities;")) def inputformat(self, data): """ Sets the input format. :param data: the data to use as input :type data: Instances """ return javabridge.call(self.jobject, "setInputFormat", "(Lweka/core/Instances;)Z", data.jobject) def input(self, inst): """ Inputs the Instance. :param inst: the instance to filter :type inst: Instance """ return self.__input(inst.jobject) def outputformat(self): """ Returns the output format. :return: the output format :rtype: Instances """ inst = self.__outputformat() if inst is None: return None else: return Instances(inst) def output(self): """ Outputs the filtered Instance. :return: the filtered instance :rtype: an Instance object """ return Instance(jobject=self.__output()) def filter(self, data): """ Filters the dataset(s). When providing a list, this can be used to create compatible train/test sets, since the filter only gets initialized with the first dataset and all subsequent datasets get transformed using the same setup. NB: inputformat(Instances) must have been called beforehand. :param data: the Instances to filter :type data: Instances or list of Instances :return: the filtered Instances object(s) :rtype: Instances or list of Instances """ if isinstance(data, list): result = [] for d in data: result.append(Instances(javabridge.static_call( "Lweka/filters/Filter;", "useFilter", "(Lweka/core/Instances;Lweka/filters/Filter;)Lweka/core/Instances;", d.jobject, self.jobject))) return result else: return Instances(javabridge.static_call( "Lweka/filters/Filter;", "useFilter", "(Lweka/core/Instances;Lweka/filters/Filter;)Lweka/core/Instances;", data.jobject, self.jobject)) class MultiFilter(Filter): """ Wrapper class for weka.filters.MultiFilter. """ def __init__(self, jobject=None, options=None): """ Initializes the MultiFilter instance using either creating new instance or using the supplied JB_Object. :param jobject: the JB_Object to use :type jobject: JB_Object :param options: list of commandline options :type options: list """ if jobject is None: classname = "weka.filters.MultiFilter" jobject = MultiFilter.new_instance(classname) self.enforce_type(jobject, "weka.filters.MultiFilter") super(MultiFilter, self).__init__(jobject=jobject, options=options) @property def filters(self): """ Returns the list of base filters. :return: the filter list :rtype: list """ objects = javabridge.get_env().get_object_array_elements( javabridge.call(self.jobject, "getFilters", "()[Lweka/filters/Filter;")) result = [] for obj in objects: result.append(Filter(jobject=obj)) return result @filters.setter def filters(self, filters): """ Sets the base filters. :param filters: the list of base filters to use :type filters: list """ obj = [] for fltr in filters: obj.append(fltr.jobject) javabridge.call(self.jobject, "setFilters", "([Lweka/filters/Filter;)V", obj) def main(): """ Runs a filter from the command-line. Calls JVM start/stop automatically. Use -h to see all options. """ parser = argparse.ArgumentParser( description='Executes a filter from the command-line. Calls JVM start/stop automatically.') parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories") parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m") parser.add_argument("-i", metavar="input1", dest="input1", required=True, help="input file 1") parser.add_argument("-o", metavar="output1", dest="output1", required=True, help="output file 1") parser.add_argument("-r", metavar="input2", dest="input2", help="input file 2") parser.add_argument("-s", metavar="output2", dest="output2", help="output file 2") parser.add_argument("-c", metavar="classindex", default="-1", dest="classindex", help="1-based class attribute index") parser.add_argument("filter", help="filter classname, e.g., weka.filters.AllFilter") parser.add_argument("option", nargs=argparse.REMAINDER, help="additional filter options") parsed = parser.parse_args() if parsed.input2 is None and not parsed.output2 is None: raise Exception("No second input file provided ('-r ...')!") jars = [] if not parsed.classpath is None: jars = parsed.classpath.split(os.pathsep) params = [] if not parsed.input1 is None: params.extend(["-i", parsed.input1]) if not parsed.output1 is None: params.extend(["-o", parsed.output1]) if not parsed.input2 is None: params.extend(["-r", parsed.input2]) if not parsed.output2 is None: params.extend(["-s", parsed.output2]) if not parsed.classindex is None: params.extend(["-c", parsed.classindex]) jvm.start(jars, max_heap_size=parsed.heap, packages=True) logger.debug("Commandline: " + utils.join_options(sys.argv[1:])) try: flter = Filter(parsed.filter) if len(parsed.option) > 0: flter.options = parsed.option loader = Loader(classname="weka.core.converters.ArffLoader") in1 = loader.load_file(parsed.input1) cls = parsed.classindex if str(parsed.classindex) == "first": cls = "0" if str(parsed.classindex) == "last": cls = str(in1.num_attributes - 1) in1.class_index = int(cls) flter.inputformat(in1) out1 = flter.filter(in1) saver = Saver(classname="weka.core.converters.ArffSaver") saver.save_file(out1, parsed.output1) if not parsed.input2 is None: in2 = loader.load_file(parsed.input2) in2.class_index = int(cls) out2 = flter.filter(in2) saver.save_file(out2, parsed.output2) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main() except Exception, ex: print(ex) python-weka-wrapper-0.2.2/python/weka/plot/0000755017267001726700000000000012452374314022322 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.2.2/python/weka/plot/dataset.py0000644017267001726700000001307712446346264024337 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # dataset.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import logging import weka.plot as plot if plot.matplotlib_available: import matplotlib.pyplot as plt from weka.core.dataset import Instances # logging setup logger = logging.getLogger(__name__) def scatter_plot(data, index_x, index_y, percent=100.0, seed=1, size=50, title=None, outfile=None, wait=True): """ Plots two attributes against each other. TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html :param data: the dataset :type data: Instances :param index_x: the 0-based index of the attribute on the x axis :type index_x: int :param index_y: the 0-based index of the attribute on the y axis :type index_y: int :param percent: the percentage of the dataset to use for plotting :type percent: float :param seed: the seed value to use for subsampling :type seed: int :param size: the size of the circles in point :type size: int :param title: an optional title :type title: str :param outfile: the (optional) file to save the generated plot to. The extension determines the file format. :type outfile: str :param wait: whether to wait for the user to close the plot :type wait: bool """ if not plot.matplotlib_available: logger.error("Matplotlib is not installed, plotting unavailable!") return # create subsample data = plot.create_subsample(data, percent=percent, seed=seed) # collect data x = [] y = [] if data.class_index == -1: c = None else: c = [] for i in xrange(data.num_instances): inst = data.get_instance(i) x.append(inst.get_value(index_x)) y.append(inst.get_value(index_y)) if not c is None: c.append(inst.get_value(inst.class_index)) # plot data fig, ax = plt.subplots() if c is None: ax.scatter(x, y, s=size, alpha=0.5) else: ax.scatter(x, y, c=c, s=size, alpha=0.5) ax.set_xlabel(data.attribute(index_x).name) ax.set_ylabel(data.attribute(index_y).name) if title is None: title = "Attribute scatter plot" if percent != 100: title += " (%0.1f%%)" % percent ax.set_title(title) ax.plot(ax.get_xlim(), ax.get_ylim(), ls="--", c="0.3") ax.grid(True) fig.canvas.set_window_title(data.relationname) plt.draw() if not outfile is None: plt.savefig(outfile) if wait: plt.show() def matrix_plot(data, percent=100.0, seed=1, size=10, title=None, outfile=None, wait=True): """ Plots all attributes against each other. TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html :param data: the dataset :type data: Instances :param percent: the percentage of the dataset to use for plotting :type percent: float :param seed: the seed value to use for subsampling :type seed: int :param size: the size of the circles in point :type size: int :param title: an optional title :type title: str :param outfile: the (optional) file to save the generated plot to. The extension determines the file format. :type outfile: str :param wait: whether to wait for the user to close the plot :type wait: bool """ if not plot.matplotlib_available: logger.error("Matplotlib is not installed, plotting unavailable!") return # create subsample data = plot.create_subsample(data, percent=percent, seed=seed) fig = plt.figure() if data.class_index == -1: c = None else: c = [] for i in xrange(data.num_instances): inst = data.get_instance(i) c.append(inst.get_value(inst.class_index)) for index_x in xrange(data.num_attributes): x = [] for i in xrange(data.num_instances): inst = data.get_instance(i) x.append(inst.get_value(index_x)) for index_y in xrange(data.num_attributes): y = [] for i in xrange(data.num_instances): inst = data.get_instance(i) y.append(inst.get_value(index_y)) ax = fig.add_subplot( data.num_attributes, data.num_attributes, index_x * data.num_attributes + index_y + 1) if c is None: ax.scatter(x, y, s=size, alpha=0.5) else: ax.scatter(x, y, c=c, s=size, alpha=0.5) ax.set_xlabel(data.attribute(index_x).name) ax.set_ylabel(data.attribute(index_y).name) ax.get_yaxis().set_ticklabels([]) ax.get_xaxis().set_ticklabels([]) ax.plot(ax.get_xlim(), ax.get_ylim(), ls="--", c="0.3") ax.grid(True) if title is None: title = data.relationname if percent != 100: title += " (%0.1f%%)" % percent fig.canvas.set_window_title(title) plt.draw() if not outfile is None: plt.savefig(outfile) if wait: plt.show() python-weka-wrapper-0.2.2/python/weka/plot/classifiers.py0000644017267001726700000002270112452331605025201 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # classifiers.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging import weka.plot as plot if plot.matplotlib_available: import matplotlib.pyplot as plt from weka.core.classes import JavaObject from weka.core.dataset import Instances from weka.classifiers import NumericPrediction, NominalPrediction # logging setup logger = logging.getLogger(__name__) def plot_classifier_errors(predictions, absolute=True, max_relative_size=50, absolute_size=50, title=None, outfile=None, wait=True): """ Plots the classifers for the given list of predictions. TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html :param predictions: the predictions to plot :type predictions: list :param absolute: whether to use absolute errors as size or relative ones :type absolute: bool :param max_relative_size: the maximum size in point in case of relative mode :type max_relative_size: int :param absolute_size: the size in point in case of absolute mode :type absolute_size: int :param title: an optional title :type title: str :param outfile: the output file, ignored if None :type outfile: str :param wait: whether to wait for the user to close the plot :type wait: bool """ if not plot.matplotlib_available: logger.error("Matplotlib is not installed, plotting unavailable!") return actual = [] predicted = [] error = None cls = None for pred in predictions: actual.append(pred.actual) predicted.append(pred.predicted) if isinstance(pred, NumericPrediction): if error is None: error = [] error.append(abs(pred.error)) elif isinstance(pred, NominalPrediction): if cls is None: cls = [] if pred.actual != pred.predicted: cls.append(1) else: cls.append(0) fig, ax = plt.subplots() if error is None and cls is None: ax.scatter(actual, predicted, s=absolute_size, alpha=0.5) elif not cls is None: ax.scatter(actual, predicted, c=cls, s=absolute_size, alpha=0.5) elif not error is None: if not absolute: min_err = min(error) max_err = max(error) factor = (max_err - min_err) / max_relative_size for i in xrange(len(error)): error[i] = error[i] / factor * max_relative_size ax.scatter(actual, predicted, s=error, alpha=0.5) ax.set_xlabel("actual") ax.set_ylabel("predicted") if title is None: title = "Classifier errors" ax.set_title(title) ax.plot(ax.get_xlim(), ax.get_ylim(), ls="--", c="0.3") ax.grid(True) fig.canvas.set_window_title(title) plt.draw() if not outfile is None: plt.savefig(outfile) if wait: plt.show() def generate_thresholdcurve_data(evaluation, class_index): """ Generates the threshold curve data from the evaluation object's predictions. :param evaluation: the evaluation to obtain the predictions from :type evaluation: Evaluation :param class_index: the 0-based index of the class-label to create the plot for :type class_index: int :return: the generated threshold curve data :rtype: Instances """ jtc = JavaObject.new_instance("weka.classifiers.evaluation.ThresholdCurve") pred = javabridge.call(evaluation.jobject, "predictions", "()Ljava/util/ArrayList;") result = Instances( javabridge.call(jtc, "getCurve", "(Ljava/util/ArrayList;I)Lweka/core/Instances;", pred, class_index)) return result def get_thresholdcurve_data(data, xname, yname): """ Retrieves x and y columns from of the data generated by the weka.classifiers.evaluation.ThresholdCurve class. :param data: the threshold curve data :type data: Instances :param xname: the name of the X column :type xname: str :param yname: the name of the Y column :type yname: str :return: tuple of x and y arrays :rtype: tuple """ xi = data.attribute_by_name(xname).index yi = data.attribute_by_name(yname).index x = [] y = [] for i in xrange(data.num_instances): inst = data.get_instance(i) x.append(inst.get_value(xi)) y.append(inst.get_value(yi)) return x, y def get_auc(data): """ Calculates the area under the ROC curve (AUC). :param data: the threshold curve data :type data: Instances :return: the area :rtype: float """ return javabridge.static_call( "weka/classifiers/evaluation/ThresholdCurve", "getROCArea", "(Lweka/core/Instances;)D", data.jobject) def get_prc(data): """ Calculates the area under the precision recall curve (PRC). :param data: the threshold curve data :type data: Instances :return: the area :rtype: float """ return javabridge.static_call( "weka/classifiers/evaluation/ThresholdCurve", "getPRCArea", "(Lweka/core/Instances;)D", data.jobject) def plot_roc(evaluation, class_index=None, title=None, key_loc="lower right", outfile=None, wait=True): """ Plots the ROC (receiver operator characteristics) curve for the given predictions. TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html :param evaluation: the evaluation to obtain the predictions from :type evaluation: Evaluation :param class_index: the list of 0-based indices of the class-labels to create the plot for :type class_index: list :param title: an optional title :type title: str :param key_loc: the position string for the key :type key_loc: str :param outfile: the output file, ignored if None :type outfile: str :param wait: whether to wait for the user to close the plot :type wait: bool """ if not plot.matplotlib_available: logger.error("Matplotlib is not installed, plotting unavailable!") return if class_index is None: class_index = [0] ax = None for cindex in class_index: data = generate_thresholdcurve_data(evaluation, cindex) head = evaluation.header area = get_auc(data) x, y = get_thresholdcurve_data(data, "False Positive Rate", "True Positive Rate") if ax is None: fig, ax = plt.subplots() ax.set_xlabel("False Positive Rate") ax.set_ylabel("True Positive Rate") if title is None: title = "ROC" ax.set_title(title) ax.grid(True) fig.canvas.set_window_title(title) plt.xlim([-0.05, 1.05]) plt.ylim([-0.05, 1.05]) plot_label = head.class_attribute.value(cindex) + " (AUC: %0.4f)" % area ax.plot(x, y, label=plot_label) ax.plot(ax.get_xlim(), ax.get_ylim(), ls="--", c="0.3") plt.draw() plt.legend(loc=key_loc, shadow=True) if not outfile is None: plt.savefig(outfile) if wait: plt.show() def plot_prc(evaluation, class_index=None, title=None, key_loc="lower center", outfile=None, wait=True): """ Plots the PRC (precision recall) curve for the given predictions. TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html :param evaluation: the evaluation to obtain the predictions from :type evaluation: Evaluation :param class_index: the list of 0-based indices of the class-labels to create the plot for :type class_index: list :param title: an optional title :type title: str :param key_loc: the location string for the key :type key_loc: str :param outfile: the output file, ignored if None :type outfile: str :param wait: whether to wait for the user to close the plot :type wait: bool """ if not plot.matplotlib_available: logger.error("Matplotlib is not installed, plotting unavailable!") return if class_index is None: class_index = [0] ax = None for cindex in class_index: data = generate_thresholdcurve_data(evaluation, cindex) head = evaluation.header area = get_prc(data) x, y = get_thresholdcurve_data(data, "Recall", "Precision") if ax is None: fig, ax = plt.subplots() ax.set_xlabel("Recall") ax.set_ylabel("Precision") if title is None: title = "PRC" ax.set_title(title) fig.canvas.set_window_title(title) plt.xlim([-0.05, 1.05]) plt.ylim([-0.05, 1.05]) ax.grid(True) plot_label = head.class_attribute.value(cindex) + " (PRC: %0.4f)" % area ax.plot(x, y, label=plot_label) ax.plot(ax.get_xlim(), ax.get_ylim(), ls="--", c="0.3") plt.draw() plt.legend(loc=key_loc, shadow=True) if not outfile is None: plt.savefig(outfile) if wait: plt.show() python-weka-wrapper-0.2.2/python/weka/plot/clusterers.py0000644017267001726700000000716012446346264025101 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # clusterers.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import logging import weka.plot as plot if plot.matplotlib_available: import matplotlib.pyplot as plt from weka.core.dataset import Instances from weka.clusterers import ClusterEvaluation # logging setup logger = logging.getLogger(__name__) def plot_cluster_assignments(evl, data, atts=None, inst_no=False, size=10, title=None, outfile=None, wait=True): """ Plots the cluster assignments against the specified attributes. TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html :param evl: the cluster evaluation to obtain the cluster assignments from :type evl: ClusterEvaluation :param data: the dataset the clusterer was evaluated against :type data: Instances :param atts: the list of attribute indices to plot, None for all :type atts: list :param inst_no: whether to include a fake attribute with the instance number :type inst_no: bool :param size: the size of the circles in point :type size: int :param title: an optional title :type title: str :param outfile: the (optional) file to save the generated plot to. The extension determines the file format. :type outfile: str :param wait: whether to wait for the user to close the plot :type wait: bool """ if not plot.matplotlib_available: logger.error("Matplotlib is not installed, plotting unavailable!") return fig = plt.figure() if data.class_index == -1: c = None else: c = [] for i in xrange(data.num_instances): inst = data.get_instance(i) c.append(inst.get_value(inst.class_index)) if atts is None: atts = [] for i in xrange(data.num_attributes): atts.append(i) num_plots = len(atts) if inst_no: num_plots += 1 clusters = evl.cluster_assignments for index, att in enumerate(atts): x = data.values(att) ax = fig.add_subplot( 1, num_plots, index + 1) if c is None: ax.scatter(clusters, x, s=size, alpha=0.5) else: ax.scatter(clusters, x, c=c, s=size, alpha=0.5) ax.set_xlabel("Clusters") ax.set_title(data.attribute(att).name) ax.get_xaxis().set_ticks(list(set(clusters))) ax.grid(True) if inst_no: x = [] for i in xrange(data.num_instances): x.append(i+1) ax = fig.add_subplot( 1, num_plots, num_plots) if c is None: ax.scatter(clusters, x, s=size, alpha=0.5) else: ax.scatter(clusters, x, c=c, s=size, alpha=0.5) ax.set_xlabel("Clusters") ax.set_title("Instance number") ax.get_xaxis().set_ticks(list(set(clusters))) ax.grid(True) if title is None: title = data.relationname fig.canvas.set_window_title(title) plt.draw() if not outfile is None: plt.savefig(outfile) if wait: plt.show() python-weka-wrapper-0.2.2/python/weka/plot/graph.py0000644017267001726700000000325612443672561024010 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # graph.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import logging import tempfile import weka.plot as plot if plot.pygraphviz_available: from pygraphviz.agraph import AGraph if plot.PIL_available: from PIL import Image # logging setup logger = logging.getLogger(__name__) def plot_dot_graph(graph, filename=None): """ Plots a graph in graphviz dot notation. :param graph: the dot notation graph :type graph: str :param filename: the (optional) file to save the generated plot to. The extension determines the file format. :type filename: str """ if not plot.pygraphviz_available: logger.error("Pygraphviz is not installed, cannot generate graph plot!") return if not plot.PIL_available: logger.error("PIL is not installed, cannot display graph plot!") return agraph = AGraph(graph) agraph.layout(prog='dot') if filename is None: filename = tempfile.mktemp(suffix=".png") agraph.draw(filename) image = Image.open(filename) image.show() python-weka-wrapper-0.2.2/python/weka/plot/__init__.py0000644017267001726700000000337212446346264024446 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # __init__.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) from weka.core.dataset import Instances from weka.core.classes import Random # check whether pygraphviz is there pygraphviz_available = False try: import pygraphviz pygraphviz_available = True except ImportError: pass # check whether PIL is there PIL_available = False try: import PIL PIL_available = True except ImportError: pass # check whether matplotlib is there matplotlib_available = False try: import matplotlib matplotlib_available = True except ImportError: pass def create_subsample(data, percent, seed=1): """ Generates a subsample of the dataset. :param data: the data to create the subsample from :type data: Instances :param percent: the percentage (0-100) :type percent: float :param seed: the seed value to use :type seed: int """ if percent <= 0 or percent >= 100: return data data = Instances.copy_instances(data) data.randomize(Random(seed)) data = Instances.copy_instances(data, 0, int(round(data.num_instances * percent / 100.0))) return data python-weka-wrapper-0.2.2/python/weka/__init__.py0000644017267001726700000000000012322574641023444 0ustar fracpetefracpete00000000000000python-weka-wrapper-0.2.2/python/weka/datagenerators.py0000644017267001726700000001426212446346264024734 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # datagenerators.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import javabridge import logging import os import sys import argparse import weka.core.jvm as jvm import weka.core.utils as utils from weka.core.classes import OptionHandler from weka.core.dataset import Instances, Instance # logging setup logger = logging.getLogger("weka.datagenerators") class DataGenerator(OptionHandler): """ Wrapper class for datagenerators. """ def __init__(self, classname=None, jobject=None, options=None): """ Initializes the specified datagenerator using either the classname or the supplied JB_Object. :param classname: the classname of the datagenerator :type classname: str :param jobject: the JB_Object to use :type jobject: JB_Object """ if jobject is None: jobject = DataGenerator.new_instance(classname) self.enforce_type(jobject, "weka.datagenerators.DataGenerator") super(DataGenerator, self).__init__(jobject=jobject, options=options) def define_data_format(self): """ Returns the data format. :return: the data format :rtype: Instances """ data = javabridge.call(self.jobject, "defineDataFormat", "()Lweka/core/Instances;") if data is None: return None else: return Instances(data) @property def single_mode_flag(self): """ Returns whether data is generated row by row (True) or in one go (False). :return: whether incremental :rtype: bool """ return javabridge.call(self.jobject, "getSingleModeFlag", "()Z") @property def dataset_format(self): """ Returns the dataset format. :return: the format :rtype: Instances """ data = javabridge.call(self.jobject, "getDatasetFormat", "()Lweka/core/Instances;") if data is None: return None else: return Instances(data) @dataset_format.setter def dataset_format(self, inst): """ Sets the dataset format. :param inst: the Instances to use as dataset format :type inst: Instances """ javabridge.call(self.jobject, "setDatasetFormat", "(Lweka/core/Instances;)V", inst.jobject) def generate_start(self): """ Returns a "start" string. :return: the start comment :rtype: str """ return javabridge.call(self.jobject, "generateStart", "()Ljava/lang/String;") @property def num_examples_act(self): """ Returns a actual number of examples to generate. :return: the number of examples :rtype: int """ return javabridge.call(self.jobject, "getNumExamplesAct", "()I") def generate_example(self): """ Returns a single Instance. :return: the next example :rtype: Instance """ data = javabridge.call(self.jobject, "generateExample", "()Lweka/core/Instance;") if data is None: return None else: return Instance(data) def generate_examples(self): """ Returns complete dataset. :return: the generated dataset :rtype: Instances """ data = javabridge.call(self.jobject, "generateExamples", "()Lweka/core/Instances;") if data is None: return None else: return Instances(data) def generate_finish(self): """ Returns a "finish" string. :return: a finish comment :rtype: str """ return javabridge.call(self.jobject, "generateFinish", "()Ljava/lang/String;") @classmethod def make_data(cls, generator, args): """ Generates data using the generator and commandline arguments. :param generator: the generator instance to use :type generator: DataGenerator :param args: the command-line arguments :type args: list """ javabridge.static_call( "Lweka/datagenerators/DataGenerator;", "makeData", "(Lweka/datagenerators/DataGenerator;[Ljava/lang/String;)V", generator.jobject, args) def main(): """ Runs a datagenerator from the command-line. Calls JVM start/stop automatically. Use -h to see all options. """ parser = argparse.ArgumentParser( description='Executes a data generator from the command-line. Calls JVM start/stop automatically.') parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories") parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m") parser.add_argument("datagenerator", help="data generator classname, e.g., weka.datagenerators.classifiers.classification.LED24") parser.add_argument("option", nargs=argparse.REMAINDER, help="additional data generator options") parsed = parser.parse_args() jars = [] if not parsed.classpath is None: jars = parsed.classpath.split(os.pathsep) jvm.start(jars, max_heap_size=parsed.heap, packages=True) logger.debug("Commandline: " + utils.join_options(sys.argv[1:])) try: generator = DataGenerator(classname=parsed.datagenerator) if len(parsed.option) > 0: generator.options = parsed.option DataGenerator.make_data(generator, parsed.option) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main() except Exception, ex: print(ex) python-weka-wrapper-0.2.2/CHANGES.rst0000644017267001726700000000644012452374166020707 0ustar fracpetefracpete00000000000000Changelog ========= 0.2.2 (2015-01-05) ------------------ - added convenience methods `no_class` (to unset class) and `has_class` (class set?) to `Instances` class - switched to using faster method objects for methods `classify_instance`/`distribution_for_instance` in `Classifier` class - switched to using faster method objects for methods `cluster_instance`/`distribution_for_instance` in `Clusterer` class - switched to using faster method objects for methods `class_index`, `is_missing`, `get/set_value`, `get/set_string_value`, `weight` in `Instance` class - switched to using faster method objects for methods `input`, `output`, `outputformat` in `Filter` class - switched to using faster method objects for methods `attribute`, `attribute_by_name`, `num_attributes`, `num_instances`, `class_index`, `class_attribute`, `set_instance`, `get_instance`, `add_instance` in `Instances` class 0.2.1 (2015-01-05) ------------------ - added unit testing framework - added method `refresh_cache()` to `weka/core/packages.py` to allow user to refresh local cache - method `get_classname` in `weka.core.utils` now handles Python objects and class objects as well - added convenience method `get_jclass` to `weka.core.utils` to instantiate a Java class - added a `JavaArray` wrapper for `arrays`, which allows getting/setting elements and iterating - added property `classname` to class `JavaObject` for easy access to classname of underlying object - added class method `parse_matlab` for parsing Matlab matrix strings to `CostMatrix` class - `predictions` method of `Evaluation` class now return `None` if predictions are discarded - `Associator.get_capabilities()` method is now a property: `Associator.capabilities` - added wrapper classes for Java enums: `weka.core.classes.Enum` - fixed retrieval of `sumSq` in `Stats` class (used by `AttributeStats`) - fixed `cluster_instance` method in `Clusterer` class - fixed `filter` and `clusterer` properties in clusterer classes (`SingleClustererEnhancer`, `FilteredClusterer`) - added `crossvalidate_model` method to `ClusterEvaluation` - added `get_prc` method to `plot/classifiers.py` for calculating the area under the precision-recall curve - `Filter.filter` method now handles list of `Instances` objects as well, applying the filter sequentially to all the datasets (allows generation of compatible train/test sets) 0.2.0 (2014-12-22) ------------------ NB: This release is not backwards compatible! - requires `JavaBridge` 1.0.9 at least - moved from Java-like get/set (`getIndex()` and `setIndex(int)`) to nicer Python properties - using Python properties (also only read-only ones) wherevere possible - added `weka.core.version` for accessing the Weka version currently in use - added `jwrapper` and `jclasswrapper` methods to `JavaObject` class (the mother of all objects in python-weka-wrapper) to allow generic access to an object's methods: http://pythonhosted.org//javabridge/highlevel.html#wrapping-java-objects-using-reflection - added convenience methods `class_is_last()` and `class_is_first()` to `weka.core.Instances` class - added convenience methods `delete_last_attribute()` and `delete_first_attribute()` to `weka.core.Instances` class Older releases -------------- https://github.com/fracpete/python-weka-wrapper/blob/7fd0bba3c74277313eb463e338c1a7e117a1ea22/CHANGES.rst python-weka-wrapper-0.2.2/MANIFEST.in0000644017267001726700000000026312352664672020643 0ustar fracpetefracpete00000000000000recursive-include python *.arff recursive-include python *.jar recursive-exclude python weka-src.jar recursive-exclude python weka.jar include DESCRIPTION.rst include CHANGES.rst python-weka-wrapper-0.2.2/setup.cfg0000644017267001726700000000026412452374314020717 0ustar fracpetefracpete00000000000000[build_sphinx] source-dir = doc/source build-dir = doc/build all_files = 1 [upload_sphinx] upload-dir = doc/build/html [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 python-weka-wrapper-0.2.2/setup.py0000644017267001726700000000706112452374207020613 0ustar fracpetefracpete00000000000000# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # setup.py # Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com) import os from setuptools import setup from urllib2 import urlopen, URLError, HTTPError def download_file(url, outfile): """ Downloads the file associated with the URL and saves it to the specified output file. Taken from here: http://stackoverflow.com/a/4028894 :param url: the URL to download :type url: str :param outfile: the name of the output file :type outfile: str :returns: whether the download was successful :rtype: bool """ try: # Open the url f = urlopen(url) print("Downloading '" + url + "' to '" + outfile + "'") # Open our local file for writing with open(outfile, "wb") as local_file: local_file.write(f.read()) # handle errors except HTTPError, e: print("HTTP Error: " + str(e.code) + " " + url) return False except URLError, e: print("URL Error: " + str(e.reason) + " " + url) return False return True def download_weka(): """ Downloads the monolithic Weka jar from sourceforget.net if nececssary. """ url = "http://sourceforge.net/projects/weka/files/weka-3-7/3.7.12/weka-3-7-12-monolithic.jar/download" outfile = os.path.join(os.path.dirname(__file__), "python", "weka", "lib", "weka.jar") if not os.path.exists(outfile): if not download_file(url, outfile): print("Failed to download Weka jar '" + url + "' to '" + outfile + "'!") else: print("Download of Weka jar successful!") def ext_modules(): """ Initiates Weka jar download. """ download_weka() def _read(f): """ Reads in the content of the file. :param f: the file to read :type f: str :return: the content :rtype: str """ return open(f, 'rb').read() setup( name="python-weka-wrapper", description="Python wrapper for the Weka Machine Learning Workbench", long_description=( _read('DESCRIPTION.rst') + b'\n' + _read('CHANGES.rst')).decode('utf-8'), url="https://github.com/fracpete/python-weka-wrapper", classifiers=[ 'Development Status :: 4 - Beta', 'License :: OSI Approved :: GNU General Public License (GPL)', 'Topic :: Scientific/Engineering :: Artificial Intelligence', 'Programming Language :: Python', ], license='GNU General Public License version 3.0 (GPLv3)', package_dir={ '': 'python' }, packages=[ "weka", "weka.core", "weka.plot" ], package_data={ "weka": ["lib/*.jar"], }, include_package_data=True, version="0.2.2", author='Peter "fracpete" Reutemann', author_email='pythonwekawrapper at gmail dot com', install_requires=[ "javabridge>=1.0.9", ], extras_require={ 'plots': ["matplotlib"], 'graphs': ["pygraphviz", "PIL"], }, ext_modules=ext_modules(), ) python-weka-wrapper-0.2.2/DESCRIPTION.rst0000644017267001726700000000031512341760024021402 0ustar fracpetefracpete00000000000000The **python-weka-wrapper** package makes it easy to run Weka algorithms and filters from within Python. It offers access to Weka API using thin wrappers around JNI calls using the **javabridge** package. python-weka-wrapper-0.2.2/PKG-INFO0000644017267001726700000001103112452374314020165 0ustar fracpetefracpete00000000000000Metadata-Version: 1.1 Name: python-weka-wrapper Version: 0.2.2 Summary: Python wrapper for the Weka Machine Learning Workbench Home-page: https://github.com/fracpete/python-weka-wrapper Author: Peter "fracpete" Reutemann Author-email: pythonwekawrapper at gmail dot com License: GNU General Public License version 3.0 (GPLv3) Description: The **python-weka-wrapper** package makes it easy to run Weka algorithms and filters from within Python. It offers access to Weka API using thin wrappers around JNI calls using the **javabridge** package. Changelog ========= 0.2.2 (2015-01-05) ------------------ - added convenience methods `no_class` (to unset class) and `has_class` (class set?) to `Instances` class - switched to using faster method objects for methods `classify_instance`/`distribution_for_instance` in `Classifier` class - switched to using faster method objects for methods `cluster_instance`/`distribution_for_instance` in `Clusterer` class - switched to using faster method objects for methods `class_index`, `is_missing`, `get/set_value`, `get/set_string_value`, `weight` in `Instance` class - switched to using faster method objects for methods `input`, `output`, `outputformat` in `Filter` class - switched to using faster method objects for methods `attribute`, `attribute_by_name`, `num_attributes`, `num_instances`, `class_index`, `class_attribute`, `set_instance`, `get_instance`, `add_instance` in `Instances` class 0.2.1 (2015-01-05) ------------------ - added unit testing framework - added method `refresh_cache()` to `weka/core/packages.py` to allow user to refresh local cache - method `get_classname` in `weka.core.utils` now handles Python objects and class objects as well - added convenience method `get_jclass` to `weka.core.utils` to instantiate a Java class - added a `JavaArray` wrapper for `arrays`, which allows getting/setting elements and iterating - added property `classname` to class `JavaObject` for easy access to classname of underlying object - added class method `parse_matlab` for parsing Matlab matrix strings to `CostMatrix` class - `predictions` method of `Evaluation` class now return `None` if predictions are discarded - `Associator.get_capabilities()` method is now a property: `Associator.capabilities` - added wrapper classes for Java enums: `weka.core.classes.Enum` - fixed retrieval of `sumSq` in `Stats` class (used by `AttributeStats`) - fixed `cluster_instance` method in `Clusterer` class - fixed `filter` and `clusterer` properties in clusterer classes (`SingleClustererEnhancer`, `FilteredClusterer`) - added `crossvalidate_model` method to `ClusterEvaluation` - added `get_prc` method to `plot/classifiers.py` for calculating the area under the precision-recall curve - `Filter.filter` method now handles list of `Instances` objects as well, applying the filter sequentially to all the datasets (allows generation of compatible train/test sets) 0.2.0 (2014-12-22) ------------------ NB: This release is not backwards compatible! - requires `JavaBridge` 1.0.9 at least - moved from Java-like get/set (`getIndex()` and `setIndex(int)`) to nicer Python properties - using Python properties (also only read-only ones) wherevere possible - added `weka.core.version` for accessing the Weka version currently in use - added `jwrapper` and `jclasswrapper` methods to `JavaObject` class (the mother of all objects in python-weka-wrapper) to allow generic access to an object's methods: http://pythonhosted.org//javabridge/highlevel.html#wrapping-java-objects-using-reflection - added convenience methods `class_is_last()` and `class_is_first()` to `weka.core.Instances` class - added convenience methods `delete_last_attribute()` and `delete_first_attribute()` to `weka.core.Instances` class Older releases -------------- https://github.com/fracpete/python-weka-wrapper/blob/7fd0bba3c74277313eb463e338c1a7e117a1ea22/CHANGES.rst Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: License :: OSI Approved :: GNU General Public License (GPL) Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence Classifier: Programming Language :: Python