python-weka-wrapper-0.1.11/0000755017267001726700000000000012407653115017152 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.1.11/python/0000755017267001726700000000000012407653115020473 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.1.11/python/python_weka_wrapper.egg-info/0000755017267001726700000000000012407653115026255 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.1.11/python/python_weka_wrapper.egg-info/dependency_links.txt0000644017267001726700000000000112407653115032323 0ustar fracpetefracpete00000000000000 python-weka-wrapper-0.1.11/python/python_weka_wrapper.egg-info/requires.txt0000644017267001726700000000007612407653115030660 0ustar fracpetefracpete00000000000000javabridge>=1.0.1 [plots] matplotlib [graphs] pygraphviz PILpython-weka-wrapper-0.1.11/python/python_weka_wrapper.egg-info/SOURCES.txt0000644017267001726700000000202512407653115030140 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/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.1.11/python/python_weka_wrapper.egg-info/top_level.txt0000644017267001726700000000000512407653115031002 0ustar fracpetefracpete00000000000000weka python-weka-wrapper-0.1.11/python/python_weka_wrapper.egg-info/PKG-INFO0000644017267001726700000001136512407653115027360 0ustar fracpetefracpete00000000000000Metadata-Version: 1.1 Name: python-weka-wrapper Version: 0.1.11 Summary: Python wrapper for the Weka Machine Learning Workbench Home-page: https://github.com/fracpete/python-weka-wrapper Author: Peter "fracpete" Reutemann Author-email: fracpete 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.1.11 (2014-09-22) ------------------- - moved `wekaexamples` module to separate github project: https://github.com/fracpete/python-weka-wrapper-examples - added `stratify`, `train_cv` and `test_cv` methods to the `Instances` class - fixed `to_summary` method of the Evaluation class: failed when providing a custom title 0.1.10 (2014-08-29) ------------------- - fixed adding custom classpath using `jvm.start(class_path=[...])` 0.1.9 (2014-08-18) ------------------ - added static methods to Instances class: `summary`, `merge_instances`, `append_instances` - added methods to Instances class: `delete_with_missing`, `equal_headers` 0.1.8 (2014-06-26) ------------------ - fixed installer: `MANIFEST.in` now includes `CHANGES.rst` and `DESCRIPTION.rst` as well 0.1.7 (2014-06-26) ------------------ - fixed `weka/plot/dataset.py` imports to avoid error when testing for matplotlib availability - `Instance.create_instance` (`weka/core/dataset.py`) now accepts Python list and Numpy array 0.1.6 (2014-05-29) ------------------ - added troubleshooting section for Mac OSX to documentation - recompiled helper jars with 1.6 rather than 1.7 to make it work on Mac OSX - added link to Google Group 0.1.5 (2014-05-23) ------------------ - added CostMatrix support in the classifier evaluation - fixed various retrievals of double arrays (accessed them incorrectly as float arrays), like `distributionForInstance` for a classifier - Instances object can now retrieve all (internal) values of an attribute/column as numpy array - added plotting of cluster assignments to `weka.plot.clusterers` - fixed `weka.core.utils.from_commandline` method - fixed `weka.classifiers.PredictionOutput` (get/set_header methods) - predictions can be turned into an `Instances` object now using `weka.classifiers.predictions_to_instances` 0.1.4 (2014-05-19) ------------------ - dependencies for plotting are now optional (pygraphviz, PIL, matplotlib) - plots now support custom titles 0.1.3 (2014-05-17) ------------------ - improved documentation - added PRC curve plot - aligned to PEP8 style guidelines - fixed variety of little bugs (not so commonly used methods) - fixed lib directory reference in make files for Java helper classes 0.1.2 (2014-05-13) ------------------ - added matrix plot - added scatter plot for two attributes - fixes in constructors of classes - added `MultiFilter` convenience class - predictions (of classifiers) can now be collected and output using the `PredictionOutput` class - added support for attribute statistics 0.1.1 (2014-05-02) ------------------ - constructors now take list of commandline options as well - added Weka package support (list/install/uninstall) - ROC plotting for classifiers - improved code documentation - added more examples - added more datasets - using javabridge 1.0.1 now 0.1.0 (2014-04-27) ------------------ - Initial release of Python wrapper for Weka, no GUI. Platform: UNKNOWN Classifier: Development Status :: 3 - Alpha Classifier: License :: OSI Approved :: GNU General Public License (GPL) Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence Classifier: Programming Language :: Python python-weka-wrapper-0.1.11/python/weka/0000755017267001726700000000000012407653115021422 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.1.11/python/weka/experiments.py0000644017267001726700000006026012336540373024345 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 (fracpete 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 get_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) def set_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) def get_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;")) def set_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 def get_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) def set_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[:] def set_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 def set_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 def set_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.get_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.get_attribute_by_name(name) if att is None: raise Exception("Dataset column not found: " + name) if len(cols) > 0: cols += "," cols += str(att.get_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.get_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.get_index()) # fold if not self.fold_column is None: att = data.get_attribute_by_name(self.fold_column) if att is None: index = -1 else: index = att.get_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.get_attribute_by_name(name) if att is None: raise Exception("Result column not found: " + name) if len(cols) > 0: cols += "," cols += str(att.get_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.1.11/python/weka/core/0000755017267001726700000000000012407653115022352 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.1.11/python/weka/core/classes.py0000644017267001726700000002774012377764417024411 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 Fracpete (fracpete at gmail dot com) import types import javabridge 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) 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)) @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.Instance") :type intf_or_class: str :param jni_intf_or_class: the classname in JNI notation (eg "Lweka/core/Instance;") :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.Instance") :type intf_or_class: str :param jni_intf_or_class: the classname in JNI notation (eg "Lweka/core/Instance;") :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.Instance") :type classname: str :param jni_classname: the classname in JNI notation (eg "Lweka/core/Instance;") :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 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") 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.set_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 def set_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 get_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 [] 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 set_upper(self, upper): """ Sets the upper limit. :param upper: the upper limit :type upper: int """ javabridge.call(self.jobject, "setUpper", "(I)V", upper) def get_index(self): """ Returns the integer index. :return: the 0-based integer index :rtype: int """ return javabridge.call(self.jobject, "getIndex", "()I") def get_single_index(self): """ Returns the string index. :return: the 1-based string index :rtype: str """ return javabridge.call(self.jobject, "getSingleIndex", "()Ljava/lang/String;") def set_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 set_upper(self, upper): """ Sets the upper limit. :param upper: the upper limit :type upper: int """ javabridge.call(self.jobject, "setUpper", "(I)V", upper) def get_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")) def get_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;") def set_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) python-weka-wrapper-0.1.11/python/weka/core/utils.py0000644017267001726700000000565512377764417024115 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 (fracpete at gmail dot com) import javabridge import logging import weka.core.types as arrays from weka.core.classes import OptionHandler # logging setup logger = logging.getLogger(__name__) 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): """ Creates an OptionHandler based on the provided commandline string. :param cmdline: the commandline string to use :type cmdline: str :return: the generated option handler instance :rtype: OptionHandler """ params = split_options(cmdline) cls = params[0] params = params[1:] return OptionHandler(jobject=javabridge.make_instance(cls.replace(".", "/"), "()V"), options=params) def get_classname(jobject): """ Returns the classname of the JB_Object. :param jobject: the java object to get the classname for :type jobject: JB_Object :return: the classname :rtype: str """ cls = javabridge.call(jobject, "getClass", "()Ljava/lang/Class;") return javabridge.call(cls, "getName", "()Ljava/lang/String;") python-weka-wrapper-0.1.11/python/weka/core/dataset.py0000644017267001726700000010306112407646761024363 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 (fracpete 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) def get_relationname(self): """ Returns the name of the dataset. :return: the name :rtype: str """ return javabridge.call(self.jobject, "relationName", "()Ljava/lang/String;") def num_attributes(self): """ Returns the number of attributes. :return: the number of attributes :rtype: int """ return javabridge.call(self.jobject, "numAttributes", "()I") def get_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(javabridge.call(self.jobject, "attribute", "(I)Lweka/core/Attribute;", index)) def get_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 = javabridge.call(self.jobject, "attribute", "(Ljava/lang/String;)Lweka/core/Attribute;", name) if att is None: return None else: return Attribute(att) def get_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 get_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) def num_instances(self): """ Returns the number of instances. :return: the number of instances :rtype: int """ return javabridge.call(self.jobject, "numInstances", "()I") def get_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;")) def get_class_index(self): """ Returns the currently set class index (0-based). :return: the class index, -1 if not set :rtype: int """ return javabridge.call(self.jobject, "classIndex", "()I") def set_class_index(self, index): """ Sets the class index (0-based). :param index: the new index, use -1 to unset :type index: int """ return javabridge.call(self.jobject, "setClassIndex", "(I)V", index) 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(javabridge.call(self.jobject, "instance", "(I)Lweka/core/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: javabridge.call(self.jobject, "add", "(Lweka/core/Instance;)Z", inst.jobject) else: javabridge.call(self.jobject, "add", "(ILweka/core/Instance;)V", 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( javabridge.call(self.jobject, "set", "(ILweka/core/Instance;)Lweka/core/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_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) def set_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) def get_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) def num_attributes(self): """ Returns the number of attributes. :return: the numer of attributes :rtype: int """ return javabridge.call(self.jobject, "numAttributes", "()I") 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") def get_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;")) def get_class_index(self): """ Returns the currently set class index. :return: the class index, -1 if not set :rtype: int """ return javabridge.call(self.jobject, "classIndex", "()I") 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 """ javabridge.call(self.jobject, "value", "(ID)V", 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 javabridge.call(self.jobject, "value", "(I)D", 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 javabridge.call(self.jobject, "setValue", "(ILjava/lang/String;)V", index, 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.call(self.jobject, "stringValue", "(I)Ljava/lang/String;", 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 javabridge.call(self.jobject, "isMissing", "(I)Z", 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") def get_weight(self): """ Returns the currently set weight. :return: the weight :rtype: float """ return javabridge.call(self.jobject, "weight", "()D") def set_weight(self, weight): """ Sets the weight. :param weight: the weight to set :type weight: float """ javabridge.call(self.jobject, "setWeight", "(D)V", weight) def get_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) def get_name(self): """ Returns the name of the attribute. :return: the name :rtype: str """ return javabridge.call(self.jobject, "name", "()Ljava/lang/String;") def get_index(self): """ Returns the index of this attribute. :return: the index :rtype: int """ return javabridge.call(self.jobject, "index", "()I") def set_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 get_weight(self): """ Returns the weight of the attribute. :return: the weight :rtype: float """ return javabridge.call(self.jobject, "weight", "()D") 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) def num_values(self): """ Returns the number of labels. :return: the number of labels :rtype: int """ return javabridge.call(self.jobject, "numValues", "()I") def get_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) 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") def get_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 get_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) def is_averagable(self): """ Returns whether the attribute is averagable. :return: whether averagable :rtype: bool """ return javabridge.call(self.jobject, "isAveragable", "()Z") 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") 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") 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") 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") 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") def get_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;") def get_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") def get_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 date 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))) 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) 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") 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") 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") 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")) 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")) 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;")) 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") 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) def count(self): """ The number of values seen. :return: The number of values seen :rtype: float """ return javabridge.get_field(self.jobject, "count", "D") 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") 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") 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") 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") def sum(self): """ The sum of values seen. :return: The sum of values seen :rtype: float """ return javabridge.get_field(self.jobject, "sum", "D") 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") python-weka-wrapper-0.1.11/python/weka/core/converters.py0000644017267001726700000001634412377764417025144 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 (fracpete 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) 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") 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: return Instances(javabridge.call(self.jobject, "getStructure", "()Lweka/core/Instances;")) 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") javabridge.call(self.jobject, "reset", "()V") javabridge.call(self.jobject, "setURL", "(Ljava/lang/String;)V", str(url)) if incremental: return Instances(javabridge.call(self.jobject, "getStructure", "()Lweka/core/Instances;")) else: return Instances(javabridge.call(self.jobject, "getDataSet", "()Lweka/core/Instances;")) def next_instance(self, structure): """ Returns the next Instance object in case the dataset is being loaded incrementally. Returns None if there are no more instances available. :param structure: the Instances object this instance belongs to :type structure: Instances :return: the next instance, None if no more available :rtype: Instance """ inst = javabridge.call( self.jobject, "getNextInstance", "(Lweka/core/Instances;)Lweka/core/Instance;", structure.jobject) if inst is None: return None else: return Instance(inst) 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 get_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.1.11/python/weka/core/jvm.py0000644017267001726700000000774712377764417023555 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 (fracpete 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.1.11/python/weka/core/serialization.py0000644017267001726700000000612012377764417025616 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 (fracpete 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.1.11/python/weka/core/packages.py0000644017267001726700000002504312377764417024524 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 (fracpete 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) def get_name(self): """ Returns the name of the package. :return: the name :rtype: str """ return javabridge.call(self.jobject, "getName", "()Ljava/lang/String;") def get_url(self): """ Returns the URL of the package. :return: the url :rtype: str """ return str(JavaObject(javabridge.call(self.jobject, "getPackageURL", "()Ljava/net/URL;"))) def get_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 def get_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;")) 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) def set_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) def get_source(self): """ Returns the source package. :return: the package :rtype: Package """ return Package( javabridge.call(self.jobject, "getSource", "()Lorg/pentaho/packageManagement/Package;")) def set_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 get_target(self): """ Returns the target package constraint. :return: the package constraint :rtype: PackageConstraint """ return PackageConstraint( javabridge.call(self.jobject, "getTarget", "()Lorg/pentaho/packageManagement/PackageConstraint;")) def establish_cache(): """ Establishes the package cache if necessary. """ javabridge.static_call( "weka/core/WekaPackageManager", "establishCacheIfNeeded", "([Ljava/io/PrintStream;)Ljava/lang/Exception;", []) def get_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 get_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 get_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 = get_installed_packages() for pkge in pkgs: if pkge.get_name() == name: return True return False if __name__ == "__main__": jvm.start() try: print("Establish cache") print("===============") establish_cache() print("All packages") print("============") packages = get_all_packages() for pkg in packages: print(pkg.get_name()) print(" url: " + pkg.get_url()) print("") print("Available packages") print("==================") packages = get_available_packages() p = packages[0] for pkg in packages: print(pkg.get_name()) print(" url: " + pkg.get_url()) print("") print("Installed packages") print("==================") packages = get_installed_packages() for pkg in packages: print(pkg.get_name()) print(" url: " + pkg.get_url()) print("") print("Install/Uninstall") print("=================") print("Install: " + p.get_name()) print(install_package(p.get_url())) print("Uninstall: " + p.get_name()) uninstall_package(p.get_name()) except Exception, e: print(e) finally: jvm.stop() python-weka-wrapper-0.1.11/python/weka/core/types.py0000644017267001726700000000574412377764417024120 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 (fracpete 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.1.11/python/weka/core/capabilities.py0000644017267001726700000003052512377764417025400 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 Fracpete (fracpete at gmail dot com) import javabridge from weka.core.classes import JavaObject from weka.core.dataset import Attribute, Instances class Capability(JavaObject): """ Wrapper for a Capability. """ def __init__(self, jobject): """ Initializes the wrapper with the specified Capability object. :param jobject: the Capability object to wrap :type jobject: JB_Object """ Capability.enforce_type(jobject, "weka.core.Capabilities$Capability") super(Capability, self).__init__(jobject) @classmethod def parse(cls, s): """ Tries to instantiate a Capability object from the string representation. :param s: the string representing a Capability :type s: str """ return Capability( javabridge.static_call( "weka/core/Capabilities$Capability", "valueOf", "(Ljava/lang/String;)Lweka/core/Capabilities$Capability;", s)) class Capabilities(JavaObject): """ Wrapper for Capabilities. """ def __init__(self, jobject): """ Initializes the wrapper with the specified Capabilities object. :param jobject: the Capabilities object to wrap :type jobject: JB_Object """ Capabilities.enforce_type(jobject, "weka.core.Capabilities") super(Capabilities, self).__init__(jobject) 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 get_attribute_capabilities(self): """ Returns all the attribute capabilities. :return: attribute capabilities :rtype: Capabilities """ return Capabilities( javabridge.call(self.jobject, "getAttributeCapabilities", "()Lweka/core/Capabilities;")) def get_class_capabilities(self): """ Returns all the class capabilities. :return: class capabilities :rtype: Capabilities """ return Capabilities( javabridge.call(self.jobject, "getClassCapabilities", "()Lweka/core/Capabilities;")) def get_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 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) def set_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 get_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") 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.1.11/python/weka/core/__init__.py0000644017267001726700000000000012322574641024453 0ustar fracpetefracpete00000000000000python-weka-wrapper-0.1.11/python/weka/classifiers.py0000644017267001726700000014472412407651244024320 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 (fracpete at gmail dot com) import sys import os import javabridge import logging import getopt 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) def get_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 javabridge.call(self.jobject, "classifyInstance", "(Lweka/core/Instance;)D", 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 = javabridge.call(self.jobject, "distributionForInstance", "(Lweka/core/Instance;)[D", inst.jobject) return javabridge.get_env().get_double_array_elements(pred) 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 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) def set_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) def get_classifier(self): """ Returns the base classifier. :rtype: Classifier """ return Classifier(javabridge.call(self.jobject, "getClassifier", "()Lweka/classifiers/Classifier;")) 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) def set_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) def get_filter(self): """ Returns the filter. :return: the filter in use :rtype: Filter """ return Filter(javabridge.call(self.jobject, "getFilter", "()Lweka/filters/Filter;")) 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) def set_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) def get_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 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) def actual(self): """ Returns the actual value. :return: the actual value (internal representation) :rtype: float """ return javabridge.call(self.jobject, "actual", "()D") def predicted(self): """ Returns the predicted value. :return: the predicted value (internal representation) :rtype: float """ return javabridge.call(self.jobject, "predicted", "()D") 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) 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")) 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) def error(self): """ Returns the error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "error", "()D") 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 :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!") 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") def num_columns(self): """ Returns the number of columns. :return: the number of columns :rtype: int """ return javabridge.call(self.jobject, "numColumns", "()I") def num_rows(self): """ Returns the number of rows. :return: the number of rows :rtype: int """ return javabridge.call(self.jobject, "numRows", "()I") 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;") 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 to_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 to_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 to_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) 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) 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") def avg_cost(self): """ Returns the average cost. :return: the cost :rtype: float """ return javabridge.call(self.jobject, "avgCost", "()D") def total_cost(self): """ Returns the total cost. :return: the cost :rtype: float """ return javabridge.call(self.jobject, "totalCost", "()D") 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")) def correct(self): """ Returns the correct count (nominal classes). :return: the count :rtype: float """ return javabridge.call(self.jobject, "correct", "()D") def incorrect(self): """ Returns the incorrect count (nominal classes). :return: the count :rtype: float """ return javabridge.call(self.jobject, "incorrect", "()D") def unclassified(self): """ Returns the unclassified count. :return: the count :rtype: float """ return javabridge.call(self.jobject, "unclassified", "()D") 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") def percent_correct(self): """ Returns the percent correct (nominal classes). :return: the percentage :rtype: float """ return javabridge.call(self.jobject, "pctCorrect", "()D") def percent_incorrect(self): """ Returns the percent incorrect (nominal classes). :return: the percentage :rtype: float """ return javabridge.call(self.jobject, "pctIncorrect", "()D") def percent_unclassified(self): """ Returns the percent unclassified. :return: the percentage :rtype: float """ return javabridge.call(self.jobject, "pctUnclassified", "()D") 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) def weighted_matthews_correlation(self): """ Returns the weighted Matthews correlation (nominal classes). :return: the correlation :rtype: float """ return javabridge.call(self.jobject, "weightedMatthewsCorrelation", "()D") 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") 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") def error_rate(self): """ Returns the error rate (numeric classes). :return: the rate :rtype: float """ return javabridge.call(self.jobject, "errorRate", "()D") def mean_absolute_error(self): """ Returns the mean absolute error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "meanAbsoluteError", "()D") def relative_absolute_error(self): """ Returns the relative absolute error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "relativeAbsoluteError", "()D") def root_mean_squared_error(self): """ Returns the root mean squared error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "rootMeanSquaredError", "()D") def root_relative_squared_error(self): """ Returns the root relative squared error. :return: the error :rtype: float """ return javabridge.call(self.jobject, "rootRelativeSquaredError", "()D") 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") 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) 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) 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) 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) 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) def weighted_f_measure(self): """ Returns the weighted f measure. :return: the measure :rtype: float """ return javabridge.call(self.jobject, "weightedFMeasure", "()D") 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") 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) 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) def weighted_recall(self): """ Returns the weighted recall. :return: the recall :rtype: float """ return javabridge.call(self.jobject, "weightedRecall", "()D") def kappa(self): """ Returns kappa. :return: kappa :rtype: float """ return javabridge.call(self.jobject, "kappa", "()D") def kb_information(self): """ Returns KB information. :return: the information :rtype: float """ return javabridge.call(self.jobject, "KBInformation", "()D") def kb_mean_information(self): """ Returns KB mean information. :return: the information :rtype: float """ return javabridge.call(self.jobject, "KBMeanInformation", "()D") def kb_relative_information(self): """ Returns KB relative information. :return: the information :rtype: float """ return javabridge.call(self.jobject, "KBRelativeInformation", "()D") 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") 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") 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") 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") def set_class_priors(self, data): """ Sets the class priors derived from the dataset. :param data: the dataset to derive the priors from :type data: Instances """ return javabridge.call(self.jobject, "setClassPriors", "(Lweka/core/Instances;)V", data) def get_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")) def header(self): """ Returns the header format. :return: the header format :rtype: Instances """ return Instances(javabridge.call(self.jobject, "getHeader", "()Lweka/core/Instances;")) def set_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) def get_discard_predictions(self): """ Returns whether to discard predictions (saves memory). :return: True if to discard :rtype: bool """ return javabridge.call(self.jobject, "getDiscardPredictions", "()Z") def predictions(self): """ Returns the predictions. :return: the predictions :rtype: list """ preds = javabridge.get_collection_wrapper( javabridge.call(self.jobject, "predictions", "()Ljava/util/ArrayList;")) 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) def set_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 get_header(self): """ Returns the header format. :return: The dataset format :rtype: Instances """ return Instances(javabridge.call(self.jobject, "getHeader", "()Lweka/core/Instances;")) 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 get_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.get_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.get_class_attribute().copy(name="actual")) atts.append(data.get_class_attribute().copy(name="predicted")) atts.append(Attribute.create_nominal("error", ["no", "yes"])) atts.append(Attribute.create_numeric("classification")) for i in xrange(data.get_class_attribute().num_values()): atts.append(Attribute.create_numeric("distribution-" + data.get_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.get_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(args): """ Runs a classifier from the command-line. Calls JVM start/stop automatically. Options: [-j jar1[:jar2...]] [-X max heap size] -t train [-T test] [-c classindex] [-d output model file] [-l input model file] [-x num folds] [-s seed] [-v # no stats for training] [-o # only stats, no model] [-i # information-retrieval stats per class] [-k # information-theoretic stats] [-m cost matrix file] [-g graph file] classifier classname [classifier options] """ usage = "Usage: weka.classifiers [-j jar1[" + os.pathsep + "jar2...]] [-X max heap size] -t train " \ + "[-T test] [-c classindex] " \ + "[-d output model file] [-l input model file] [-x num folds] [-s seed] [-v # no stats for training] " \ + "[-o # only stats, no model] [-i # information-retrieval stats per class] " \ + "-kl # information-theoretic stats] [-m cost matrix file] [-g graph file] " \ + "classifier classname [classifier options]" optlist, optargs = getopt.getopt(args, "j:X:t:T:c:d:l:x:s:voikm:g:h") if len(optargs) == 0: raise Exception("No classifier classname provided!\n" + usage) for opt in optlist: if opt[0] == "-h": print(usage) return jars = [] params = [] train = None heap = None for opt in optlist: if opt[0] == "-j": jars = opt[1].split(os.pathsep) elif opt[0] == "-X": heap = opt[1] elif opt[0] in ["-v", "-o", "-i", "-k"]: params.append(opt[0]) elif opt[0] in ["-t", "-T", "-c", "-d", "-l", "-x", "-s", "-m", "-g"]: params.append(opt[0]) params.append(opt[1]) if opt[0] == "-t": train = opt[1] # check parameters if train is None: raise Exception("No train file provided ('-t ...')!") jvm.start(jars, max_heap_size=heap, packages=True) logger.debug("Commandline: " + wutils.join_options(args)) try: classifier = Classifier(classname=optargs[0]) optargs = optargs[1:] if len(optargs) > 0: classifier.set_options(optargs) print(Evaluation.evaluate_model(classifier, params)) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main(sys.argv[1:]) except Exception, ex: print(ex) python-weka-wrapper-0.1.11/python/weka/associations.py0000644017267001726700000001005212335640615024472 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 (fracpete at gmail dot com) import javabridge import logging import os import sys import getopt 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) def get_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(args): """ Runs a associator from the command-line. Calls JVM start/stop automatically. Options: [-j jar1[:jar2...]] [-X max heap size] -t train associator classname [associator options] """ usage = "Usage: weka.associators [-j jar1[" + os.pathsep + "jar2...]] [-X max heap size] -t train [-T test] " \ + "associator classname [associator options]" optlist, optargs = getopt.getopt(args, "j:X:t:h") if len(optargs) == 0: raise Exception("No associator classname provided!\n" + usage) for opt in optlist: if opt[0] == "-h": print(usage) return jars = [] params = [] train = None heap = None for opt in optlist: if opt[0] == "-j": jars = opt[1].split(os.pathsep) elif opt[0] == "-X": heap = opt[1] elif opt[0] == "-t": params.append(opt[0]) params.append(opt[1]) train = opt[1] # check parameters if train is None: raise Exception("No train file provided ('-t ...')!") jvm.start(jars, max_heap_size=heap, packages=True) logger.debug("Commandline: " + utils.join_options(args)) try: associator = Associator(classname=optargs[0]) optargs = optargs[1:] if len(optargs) > 0: associator.set_options(optargs) loader = converters.loader_for_file(train) data = loader.load_file(train) associator.build_associations(data) print(str(associator)) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main(sys.argv[1:]) except Exception, ex: print(ex) python-weka-wrapper-0.1.11/python/weka/clusterers.py0000644017267001726700000003113612407234420024165 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 (fracpete at gmail dot com) import javabridge import logging import os import sys import getopt 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.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) def get_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 javabridge.call(self.jobject, "clusterInstance", "(Lweka/core/Instance;)D", 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 = javabridge.call(self.jobject, "distributionForInstance", "(Lweka/core/Instance;)[D", inst.jobject) return javabridge.get_env().get_double_array_elements(pred) 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") 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 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) def set_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) def get_clusterer(self): """ Returns the base clusterer. :return: the clusterer :rtype: Clusterer """ return Clusterer(javabridge.call(self.jobject, "getClusterer", "()Lweka/clusterers/Clusterer;")) 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) def set_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) def get_filter(self): """ Returns the filter. :return: the filter :rtype: Filter """ return Filter(javabridge.call(self.jobject, "getFilter", "()Lweka/filters/Filter;")) 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) def get_cluster_results(self): """ The cluster results as string. :return: the results string :rtype: str """ return javabridge.call(self.jobject, "clusterResultsToString", "()Ljava/lang/String;") def get_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) def get_num_clusters(self): """ Returns the number of clusters. :return: the number of clusters :rtype: int """ return javabridge.call(self.jobject, "getNumClusters", "()I") def get_log_likelihood(self): """ Returns the log likelihood. :return: the log likelihood :rtype: float """ return javabridge.call(self.jobject, "getLogLikelihood", "()D") def get_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) def main(args): """ Runs a clusterer from the command-line. Calls JVM start/stop automatically. Options: [-j jar1[:jar2...]] [-X max heap size] -t train [-T test] [-d output model file] [-l input model file] [-p attribute range] [-x num folds] [-s seed] [-c classindex] [-g graph file] clusterer classname [clusterer options] """ usage = "Usage: weka.clusterers [-j jar1[" + os.pathsep + "jar2...]] [-X max heap size] " \ + "-t train [-T test] [-d output model file] [-l input model file] " \ + "[-p attribute range] [-x num folds] [-s seed] [-c classindex] " \ + "[-g graph file] clusterer classname [clusterer options]" optlist, optargs = getopt.getopt(args, "j:X:t:T:d:l:p:x:s:c:g:h") if len(optargs) == 0: raise Exception("No clusterer classname provided!\n" + usage) for opt in optlist: if opt[0] == "-h": print(usage) return jars = [] params = [] train = None heap = None for opt in optlist: if opt[0] == "-j": jars = opt[1].split(os.pathsep) elif opt[0] == "-X": heap = opt[1] elif opt[0] in ["-t", "-T", "-d", "-l", "-p", "-x", "-s", "-c", "-g"]: params.append(opt[0]) params.append(opt[1]) if opt[0] == "-t": train = opt[1] # check parameters if train is None: raise Exception("No train file provided ('-t ...')!") jvm.start(jars, max_heap_size=heap, packages=True) logger.debug("Commandline: " + utils.join_options(args)) try: clusterer = Clusterer(classname=optargs[0]) optargs = optargs[1:] if len(optargs) > 0: clusterer.set_options(optargs) print(ClusterEvaluation.evaluate_clusterer(clusterer, params)) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main(sys.argv[1:]) except Exception, ex: print(ex) python-weka-wrapper-0.1.11/python/weka/attribute_selection.py0000644017267001726700000002751512407234420026050 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 (fracpete at gmail dot com) import javabridge import logging import os import sys import getopt 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) def get_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 set_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 set_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 set_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 set_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 set_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 set_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) def get_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) def to_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;") def get_cv_results_string(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;") def get_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") def get_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(args): """ Runs attribute selection from the command-line. Calls JVM start/stop automatically. Options: [-j jar1[:jar2...]] [-X max heap size] -i train [-c classindex] [-s search method] [-x num folds] [-n seed] evaluator classname """ usage = "Usage: weka.attribute_selection [-j jar1[" + os.pathsep + "jar2...]] [-X max heap size] " \ + "-i input file [-c classindex] " \ + "[-s search method][-x num folds] [-n seed] " \ + "evaluator classname [evaluator options]" optlist, optargs = getopt.getopt(args, "j:X:i:c:s:x:n:h") if len(optargs) == 0: raise Exception("No evaluator classname provided!\n" + usage) for opt in optlist: if opt[0] == "-h": print(usage) return jars = [] params = [] inputf = None heap = None for opt in optlist: if opt[0] == "-j": jars = opt[1].split(os.pathsep) elif opt[0] == "-X": heap = opt[1] elif opt[0] in ["-i", "-c", "-s", "-x", "-n"]: params.append(opt[0]) params.append(opt[1]) if opt[0] == "-i": inputf = opt[1] # check parameters if inputf is None: raise Exception("No input file provided ('-i ...')!") jvm.start(jars, max_heap_size=heap, packages=True) logger.debug("Commandline: " + utils.join_options(args)) try: evaluation = ASEvaluation(classname=optargs[0]) optargs = optargs[1:] if len(optargs) > 0: evaluation.set_options(optargs) print(AttributeSelection.attribute_selection(evaluation, params)) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main(sys.argv[1:]) except Exception, ex: print(ex) python-weka-wrapper-0.1.11/python/weka/lib/0000755017267001726700000000000012407653115022170 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.1.11/python/weka/lib/python-weka-wrapper.jar0000644017267001726700000000243612341525576026625 0ustar fracpetefracpete00000000000000PK|D META-INF/PKPK|DMETA-INF/MANIFEST.MFMLK-. K-*ϳR03r.JM,IMu ě*h%&*8%krrPKXECDPK |Dweka/PK |Dweka/classifiers/PK|D(weka/classifiers/EvaluationWrapper.class]OAi C"壀BTieABA ѴhRL,Q/9ުQhGgŖg=Ϝ9?}:cАC Q\@c14Z K0 99ֹQ!ՙk uD(JuFnjGB6(u*oJGYؼ[RdDE)dkW/6;fê〙f`Vcs{ƃ tFLwBcke%2T;+56(!Ԗ{.|n'fp.|J;jdYY홾Gx?]^E`6_LW+n`1YWwד%wj+|,6,l/̮Hq sHtqxDZmL.>vcX&k\uMD[UGlP<āt':d}oDU>'WLm0//^󘈤"a֯8m2j:Q ^(L \6;aNa|Xu\:z{\ntc1P3_OԉӦw_?s_1ˠ7(qGO+@(. # filters.py # Copyright (C) 2014 Fracpete (fracpete at gmail dot com) import javabridge import logging import os import sys import getopt 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) def get_capabilities(self): """ Returns the capabilities of the filter. :return: the capabilities :rtype: Capabilities """ return Capabilities(javabridge.call(self.jobject, "getCapabilities", "()Lweka/core/Capabilities;")) def set_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 javabridge.call(self.jobject, "input", "(Lweka/core/Instance;)Z", inst.jobject) def get_outputformat(self): """ Returns the output format. :return: the output format :rtype: Instances """ inst = javabridge.call(self.jobject, "getOutputFormat", "()Lweka/core/Instances;") 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(javabridge.call(self.jobject, "output", "()Lweka/core/Instance;")) def filter(self, data): """ Filters the dataset. :param data: the Instances to filter :type data: Instances :return: the filtered Instances object :rtype: Instances """ 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) def set_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 get_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 def main(args): """ Runs a filter from the command-line. Calls JVM start/stop automatically. Options: [-j jar1[:jar2...]] [-X max heap size] -i input1 -o output1 [-r input2] [-s output2] [-c classindex] filter classname [filter options] """ usage = "Usage: weka.filters [-j jar1[" + os.pathsep + "jar2...]] [-X max heap size] -i input1 -o output1 " \ + "[-r input2 -s output2] [-c classindex] filterclass [filter options]" optlist, optargs = getopt.getopt(args, "j:X:i:o:r:s:c:h") if len(optargs) == 0: raise Exception("No filter classname provided!\n" + usage) for opt in optlist: if opt[0] == "-h": print(usage) return jars = [] input1 = None output1 = None input2 = None output2 = None cls = "-1" heap = None for opt in optlist: if opt[0] == "-j": jars = opt[1].split(os.pathsep) elif opt[0] == "-X": heap = opt[1] elif opt[0] == "-i": input1 = opt[1] elif opt[0] == "-o": output1 = opt[1] elif opt[0] == "-r": input2 = opt[1] elif opt[0] == "-s": output2 = opt[1] elif opt[0] == "-c": cls = opt[1] # check parameters if input1 is None: raise Exception("No input file provided ('-i ...')!") if output1 is None: raise Exception("No output file provided ('-o ...')!") if not input2 is None and output2 is None: raise Exception("No 2nd output file provided ('-s ...')!") jvm.start(jars, max_heap_size=heap, packages=True) logger.debug("Commandline: " + utils.join_options(args)) try: flter = Filter(classname=optargs[0]) optargs = optargs[1:] if len(optargs) > 0: flter.set_options(optargs) loader = Loader("weka.core.converters.ArffLoader") in1 = loader.load_file(input1) if str(cls) == "first": cls = "0" if str(cls) == "last": cls = str(in1.num_attributes() - 1) in1.set_class_index(int(cls)) flter.set_inputformat(in1) out1 = flter.filter(in1) saver = Saver("weka.core.converters.ArffSaver") saver.save_file(out1, output1) if not input2 is None: in2 = loader.load_file(input2) in2.set_class_index(int(cls)) out2 = flter.filter(in2) saver.save_file(out2, output2) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main(sys.argv[1:]) except Exception, ex: print(ex) python-weka-wrapper-0.1.11/python/weka/plot/0000755017267001726700000000000012407653115022400 5ustar fracpetefracpete00000000000000python-weka-wrapper-0.1.11/python/weka/plot/dataset.py0000644017267001726700000001322412352647617024412 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 (fracpete 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.get_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.get_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.get_attribute(index_x).get_name()) ax.set_ylabel(data.get_attribute(index_y).get_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.get_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.get_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.get_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.get_attribute(index_x).get_name()) ax.set_ylabel(data.get_attribute(index_y).get_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.get_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.1.11/python/weka/plot/classifiers.py0000644017267001726700000002021512377764424025275 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 (fracpete 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.get_attribute_by_name(xname).get_index() yi = data.get_attribute_by_name(yname).get_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 plot_roc(evaluation, class_index=0, title=None, 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 0-based index of the class-label to create the plot for :type class_index: 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 data = generate_thresholdcurve_data(evaluation, class_index) area = get_auc(data) x, y = get_thresholdcurve_data(data, "False Positive Rate", "True Positive Rate") fig, ax = plt.subplots() ax.plot(x, y) ax.set_xlabel("False Positive Rate") ax.set_ylabel("True Positive Rate") if title is None: title = "ROC" title += " (%0.4f)" % area 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.xlim([-0.05, 1.05]) plt.ylim([-0.05, 1.05]) plt.draw() if not outfile is None: plt.savefig(outfile) if wait: plt.show() def plot_prc(evaluation, class_index=0, title=None, 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 0-based index of the class-label to create the plot for :type class_index: 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 data = generate_thresholdcurve_data(evaluation, class_index) x, y = get_thresholdcurve_data(data, "Recall", "Precision") fig, ax = plt.subplots() ax.plot(x, y) ax.set_xlabel("Recall") ax.set_ylabel("Precision") if title is None: title = "PRC" 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.xlim([-0.05, 1.05]) plt.ylim([-0.05, 1.05]) plt.draw() if not outfile is None: plt.savefig(outfile) if wait: plt.show() python-weka-wrapper-0.1.11/python/weka/plot/clusterers.py0000644017267001726700000000724512377764424025171 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 (fracpete 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.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.get_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.get_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.get_cluster_assignments() for index, att in enumerate(atts): x = data.get_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.get_attribute(att).get_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.get_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.1.11/python/weka/plot/graph.py0000644017267001726700000000324512336252075024060 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 (fracpete 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.1.11/python/weka/plot/__init__.py0000644017267001726700000000336312337026273024517 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 (fracpete 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.1.11/python/weka/__init__.py0000644017267001726700000000000012322574641023523 0ustar fracpetefracpete00000000000000python-weka-wrapper-0.1.11/python/weka/datagenerators.py0000644017267001726700000001425612335641012025000 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 (fracpete at gmail dot com) import javabridge import logging import os import sys import getopt 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) def get_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") def get_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) def set_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;") def get_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(args): """ Runs a datagenerator from the command-line. Calls JVM start/stop automatically. Options: [-j jar1[:jar2...]] [-X max heap size] -o output [-S seed] [-r relation] datagenerator classname [datagenerator options] """ usage = "Usage: weka.datagenerators [-j jar1[" + os.pathsep + "jar2...]] [-X max heap size] " \ + "datagenerator classname -o output [-S seed] [-r relation] [datagenerator options]" optlist, optargs = getopt.getopt(args, "j:X:h") if len(optargs) == 0: raise Exception("No datagenerator classname provided!\n" + usage) for opt in optlist: if opt[0] == "-h": print(usage) return jars = [] heap = None for opt in optlist: if opt[0] == "-j": jars = opt[1].split(os.pathsep) elif opt[0] == "-X": heap = opt[1] jvm.start(jars, max_heap_size=heap, packages=True) logger.debug("Commandline: " + utils.join_options(args)) try: generator = DataGenerator(classname=optargs[0]) optargs = optargs[1:] if len(optargs) > 0: generator.set_options(optargs) DataGenerator.make_data(generator, optargs) except Exception, e: print(e) finally: jvm.stop() if __name__ == "__main__": try: main(sys.argv[1:]) except Exception, ex: print(ex) python-weka-wrapper-0.1.11/CHANGES.rst0000644017267001726700000000566312407651411020763 0ustar fracpetefracpete00000000000000Changelog ========= 0.1.11 (2014-09-22) ------------------- - moved `wekaexamples` module to separate github project: https://github.com/fracpete/python-weka-wrapper-examples - added `stratify`, `train_cv` and `test_cv` methods to the `Instances` class - fixed `to_summary` method of the Evaluation class: failed when providing a custom title 0.1.10 (2014-08-29) ------------------- - fixed adding custom classpath using `jvm.start(class_path=[...])` 0.1.9 (2014-08-18) ------------------ - added static methods to Instances class: `summary`, `merge_instances`, `append_instances` - added methods to Instances class: `delete_with_missing`, `equal_headers` 0.1.8 (2014-06-26) ------------------ - fixed installer: `MANIFEST.in` now includes `CHANGES.rst` and `DESCRIPTION.rst` as well 0.1.7 (2014-06-26) ------------------ - fixed `weka/plot/dataset.py` imports to avoid error when testing for matplotlib availability - `Instance.create_instance` (`weka/core/dataset.py`) now accepts Python list and Numpy array 0.1.6 (2014-05-29) ------------------ - added troubleshooting section for Mac OSX to documentation - recompiled helper jars with 1.6 rather than 1.7 to make it work on Mac OSX - added link to Google Group 0.1.5 (2014-05-23) ------------------ - added CostMatrix support in the classifier evaluation - fixed various retrievals of double arrays (accessed them incorrectly as float arrays), like `distributionForInstance` for a classifier - Instances object can now retrieve all (internal) values of an attribute/column as numpy array - added plotting of cluster assignments to `weka.plot.clusterers` - fixed `weka.core.utils.from_commandline` method - fixed `weka.classifiers.PredictionOutput` (get/set_header methods) - predictions can be turned into an `Instances` object now using `weka.classifiers.predictions_to_instances` 0.1.4 (2014-05-19) ------------------ - dependencies for plotting are now optional (pygraphviz, PIL, matplotlib) - plots now support custom titles 0.1.3 (2014-05-17) ------------------ - improved documentation - added PRC curve plot - aligned to PEP8 style guidelines - fixed variety of little bugs (not so commonly used methods) - fixed lib directory reference in make files for Java helper classes 0.1.2 (2014-05-13) ------------------ - added matrix plot - added scatter plot for two attributes - fixes in constructors of classes - added `MultiFilter` convenience class - predictions (of classifiers) can now be collected and output using the `PredictionOutput` class - added support for attribute statistics 0.1.1 (2014-05-02) ------------------ - constructors now take list of commandline options as well - added Weka package support (list/install/uninstall) - ROC plotting for classifiers - improved code documentation - added more examples - added more datasets - using javabridge 1.0.1 now 0.1.0 (2014-04-27) ------------------ - Initial release of Python wrapper for Weka, no GUI. python-weka-wrapper-0.1.11/MANIFEST.in0000644017267001726700000000026312352664672020722 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.1.11/setup.cfg0000644017267001726700000000026412407653115020775 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.1.11/setup.py0000644017267001726700000000664312407652063020676 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 (fracpete 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:", e.code, url return False except URLError, e: print "URL Error:", 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.11/weka-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 :: 3 - Alpha', '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" ], version="0.1.11", author='Peter "fracpete" Reutemann', author_email='fracpete at gmail dot com', install_requires=[ "javabridge>=1.0.1", ], extras_require={ 'plots': ["matplotlib"], 'graphs': ["pygraphviz", "PIL"], }, ext_modules=ext_modules(), ) python-weka-wrapper-0.1.11/DESCRIPTION.rst0000644017267001726700000000031512341760024021461 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.1.11/PKG-INFO0000644017267001726700000001136512407653115020255 0ustar fracpetefracpete00000000000000Metadata-Version: 1.1 Name: python-weka-wrapper Version: 0.1.11 Summary: Python wrapper for the Weka Machine Learning Workbench Home-page: https://github.com/fracpete/python-weka-wrapper Author: Peter "fracpete" Reutemann Author-email: fracpete 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.1.11 (2014-09-22) ------------------- - moved `wekaexamples` module to separate github project: https://github.com/fracpete/python-weka-wrapper-examples - added `stratify`, `train_cv` and `test_cv` methods to the `Instances` class - fixed `to_summary` method of the Evaluation class: failed when providing a custom title 0.1.10 (2014-08-29) ------------------- - fixed adding custom classpath using `jvm.start(class_path=[...])` 0.1.9 (2014-08-18) ------------------ - added static methods to Instances class: `summary`, `merge_instances`, `append_instances` - added methods to Instances class: `delete_with_missing`, `equal_headers` 0.1.8 (2014-06-26) ------------------ - fixed installer: `MANIFEST.in` now includes `CHANGES.rst` and `DESCRIPTION.rst` as well 0.1.7 (2014-06-26) ------------------ - fixed `weka/plot/dataset.py` imports to avoid error when testing for matplotlib availability - `Instance.create_instance` (`weka/core/dataset.py`) now accepts Python list and Numpy array 0.1.6 (2014-05-29) ------------------ - added troubleshooting section for Mac OSX to documentation - recompiled helper jars with 1.6 rather than 1.7 to make it work on Mac OSX - added link to Google Group 0.1.5 (2014-05-23) ------------------ - added CostMatrix support in the classifier evaluation - fixed various retrievals of double arrays (accessed them incorrectly as float arrays), like `distributionForInstance` for a classifier - Instances object can now retrieve all (internal) values of an attribute/column as numpy array - added plotting of cluster assignments to `weka.plot.clusterers` - fixed `weka.core.utils.from_commandline` method - fixed `weka.classifiers.PredictionOutput` (get/set_header methods) - predictions can be turned into an `Instances` object now using `weka.classifiers.predictions_to_instances` 0.1.4 (2014-05-19) ------------------ - dependencies for plotting are now optional (pygraphviz, PIL, matplotlib) - plots now support custom titles 0.1.3 (2014-05-17) ------------------ - improved documentation - added PRC curve plot - aligned to PEP8 style guidelines - fixed variety of little bugs (not so commonly used methods) - fixed lib directory reference in make files for Java helper classes 0.1.2 (2014-05-13) ------------------ - added matrix plot - added scatter plot for two attributes - fixes in constructors of classes - added `MultiFilter` convenience class - predictions (of classifiers) can now be collected and output using the `PredictionOutput` class - added support for attribute statistics 0.1.1 (2014-05-02) ------------------ - constructors now take list of commandline options as well - added Weka package support (list/install/uninstall) - ROC plotting for classifiers - improved code documentation - added more examples - added more datasets - using javabridge 1.0.1 now 0.1.0 (2014-04-27) ------------------ - Initial release of Python wrapper for Weka, no GUI. Platform: UNKNOWN Classifier: Development Status :: 3 - Alpha Classifier: License :: OSI Approved :: GNU General Public License (GPL) Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence Classifier: Programming Language :: Python