python-weka-wrapper-0.1.15/ 0000755 0172670 0172670 00000000000 12444361245 017157 5 ustar fracpete fracpete 0000000 0000000 python-weka-wrapper-0.1.15/python/ 0000755 0172670 0172670 00000000000 12444361245 020500 5 ustar fracpete fracpete 0000000 0000000 python-weka-wrapper-0.1.15/python/python_weka_wrapper.egg-info/ 0000755 0172670 0172670 00000000000 12444361245 026262 5 ustar fracpete fracpete 0000000 0000000 python-weka-wrapper-0.1.15/python/python_weka_wrapper.egg-info/dependency_links.txt 0000644 0172670 0172670 00000000001 12444361244 032327 0 ustar fracpete fracpete 0000000 0000000
python-weka-wrapper-0.1.15/python/python_weka_wrapper.egg-info/requires.txt 0000644 0172670 0172670 00000000076 12444361244 030664 0 ustar fracpete fracpete 0000000 0000000 javabridge>=1.0.1
[plots]
matplotlib
[graphs]
pygraphviz
PIL python-weka-wrapper-0.1.15/python/python_weka_wrapper.egg-info/SOURCES.txt 0000644 0172670 0172670 00000002025 12444361245 030145 0 ustar fracpete fracpete 0000000 0000000 CHANGES.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.py python-weka-wrapper-0.1.15/python/python_weka_wrapper.egg-info/top_level.txt 0000644 0172670 0172670 00000000005 12444361244 031006 0 ustar fracpete fracpete 0000000 0000000 weka
python-weka-wrapper-0.1.15/python/python_weka_wrapper.egg-info/PKG-INFO 0000644 0172670 0172670 00000014552 12444361244 027365 0 ustar fracpete fracpete 0000000 0000000 Metadata-Version: 1.1
Name: python-weka-wrapper
Version: 0.1.15
Summary: Python wrapper for the Weka Machine Learning Workbench
Home-page: https://github.com/fracpete/python-weka-wrapper
Author: Peter "fracpete" Reutemann
Author-email: pythonwekawrapper at gmail dot com
License: GNU General Public License version 3.0 (GPLv3)
Description: The **python-weka-wrapper** package makes it easy to run
Weka algorithms and filters from within Python. It offers access to Weka
API using thin wrappers around JNI calls using the **javabridge** package.
Changelog
=========
0.1.15 (2014-12-18)
-------------------
- fixed `Instance.set_value` method: https://github.com/fracpete/python-weka-wrapper/issues/24
- added sub-section `From source` to section on installing the library
- upgraded to Weka 3.7.12
0.1.14 (2014-12-16)
-------------------
- fixed `setup.py` to include the jars again when using eggs (via `include_package_data` etc)
- added detailed instructions for installing the library
0.1.13 (2014-11-01)
-------------------
- added `get_class` method to `weka.core.utils` which returns the Python class object associated
with the classname in dot-notation
- `from_commandline` method in `weka.core.utils` now takes an optional `classname` argument, which is
the classname (in dot-notation) of the wrapper class to return - instead of the generic `OptionHandler`
- added `Kernel` and `KernelClassifier` convenience classes to better handle kernel based classifiers
0.1.12 (2014-10-17)
-------------------
- added `create_string` class method to the `Attribute` class for creating a string attribute
- ROC/PRC curves can now consist of multiple plots (ie multiple class labels)
- switched command-line option handling from `getopt` to `argparse`
- fixed Instance.get_dataset(self) method
- added iterators for: rows/attributes in dataset, values in dataset row
- incremental loaders can be iterated now
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.15/python/weka/ 0000755 0172670 0172670 00000000000 12444361245 021427 5 ustar fracpete fracpete 0000000 0000000 python-weka-wrapper-0.1.15/python/weka/experiments.py 0000644 0172670 0172670 00000060271 12443672502 024352 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# experiments.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import logging
import javabridge
import weka.core.utils as utils
from weka.core.classes import OptionHandler, Range
from weka.core.dataset import Instances
from weka.classifiers import Classifier
# logging setup
logger = logging.getLogger("weka.experiments")
class Experiment(OptionHandler):
"""
Wrapper class for an experiment.
"""
def __init__(self, classname=None, jobject=None, options=None):
"""
Initializes the specified experiment using either the classname or the supplied JB_Object.
:param classname: the classname of the experiment
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: the list of commandline options to use
:type options: list
"""
if jobject is None:
jobject = Experiment.new_instance(classname)
super(Experiment, self).__init__(jobject=jobject, options=options)
class SimpleExperiment(OptionHandler):
"""
Ancestor for simple experiments.
See following URL for how to use the Experiment API:
http://weka.wikispaces.com/Using+the+Experiment+API
"""
def __init__(self, datasets, classifiers, jobject=None, classification=True, runs=10, result=None):
"""
Initializes the experiment.
:param datasets: the filenames of datasets to use in the experiment
:type datasets: list
:param classifiers: the Classifier objects or commandline strings to use in the experiment
:type classifiers: list
:param jobject: the Java Object to use
:type jobject: JB_Object
:param classification: whether to perform classification or regression
:type classification:bool
:param runs: the number of runs to perform
:type runs: int
:param result: the filename of the file to store the results in
:type result: str
"""
if not jobject is None:
self.enforce_type(jobject, "weka.experiment.Experiment")
if jobject is None:
jobject = javabridge.make_instance("weka/experiment/Experiment", "()V")
self.classification = classification
self.runs = runs
self.datasets = datasets[:]
self.classifiers = classifiers[:]
self.result = result
super(SimpleExperiment, self).__init__(jobject=jobject)
def configure_splitevaluator(self):
"""
Configures and returns the SplitEvaluator and Classifier instance as tuple.
:return: evaluator and classifier
:rtype: tuple
"""
if self.classification:
speval = javabridge.make_instance("weka/experiment/ClassifierSplitEvaluator", "()V")
else:
speval = javabridge.make_instance("weka/experiment/RegressionSplitEvaluator", "()V")
classifier = javabridge.call(speval, "getClassifier", "()Lweka/classifiers/Classifier;")
return speval, classifier
def configure_resultproducer(self):
"""
Configures and returns the ResultProducer and PropertyPath as tuple.
:return: producer and property path
:rtype: tuple
"""
raise Exception("Not implemented!")
def setup(self):
"""
Initializes the experiment.
"""
# basic options
javabridge.call(
self.jobject, "setPropertyArray", "(Ljava/lang/Object;)V",
javabridge.get_env().make_object_array(0, javabridge.get_env().find_class("weka/classifiers/Classifier")))
javabridge.call(
self.jobject, "setUsePropertyIterator", "(Z)V", True)
javabridge.call(
self.jobject, "setRunLower", "(I)V", 1)
javabridge.call(
self.jobject, "setRunUpper", "(I)V", self.runs)
# setup result producer
rproducer, prop_path = self.configure_resultproducer()
javabridge.call(
self.jobject, "setResultProducer", "(Lweka/experiment/ResultProducer;)V", rproducer)
javabridge.call(
self.jobject, "setPropertyPath", "([Lweka/experiment/PropertyNode;)V", prop_path)
# classifiers
classifiers = javabridge.get_env().make_object_array(
len(self.classifiers), javabridge.get_env().find_class("weka/classifiers/Classifier"))
for i, classifier in enumerate(self.classifiers):
if type(classifier) is Classifier:
javabridge.get_env().set_object_array_element(
classifiers, i, classifier.jobject)
else:
javabridge.get_env().set_object_array_element(
classifiers, i, utils.from_commandline(classifier).jobject)
javabridge.call(
self.jobject, "setPropertyArray", "(Ljava/lang/Object;)V",
classifiers)
# datasets
datasets = javabridge.make_instance("javax/swing/DefaultListModel", "()V")
for dataset in self.datasets:
f = javabridge.make_instance("java/io/File", "(Ljava/lang/String;)V", dataset)
javabridge.call(datasets, "addElement", "(Ljava/lang/Object;)V", f)
javabridge.call(
self.jobject, "setDatasets", "(Ljavax/swing/DefaultListModel;)V", datasets)
# output file
if str(self.result).lower().endswith(".arff"):
rlistener = javabridge.make_instance("weka/experiment/InstancesResultListener", "()V")
elif str(self.result).lower().endswith(".csv"):
rlistener = javabridge.make_instance("weka/experiment/CSVResultListener", "()V")
else:
raise Exception("Unhandled output format for results: " + self.result)
rfile = javabridge.make_instance("java/io/File", "(Ljava/lang/String;)V", self.result)
javabridge.call(
rlistener, "setOutputFile", "(Ljava/io/File;)V", rfile)
javabridge.call(
self.jobject, "setResultListener", "(Lweka/experiment/ResultListener;)V", rlistener)
def run(self):
"""
Executes the experiment.
"""
logger.info("Initializing...")
javabridge.call(self.jobject, "initialize", "()V")
logger.info("Running...")
javabridge.call(self.jobject, "runExperiment", "()V")
logger.info("Finished...")
javabridge.call(self.jobject, "postProcess", "()V")
def 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.15/python/weka/core/ 0000755 0172670 0172670 00000000000 12444361245 022357 5 ustar fracpete fracpete 0000000 0000000 python-weka-wrapper-0.1.15/python/weka/core/classes.py 0000644 0172670 0172670 00000027751 12443672513 024404 0 ustar fracpete fracpete 0000000 0000000 # 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 (pythonwekawrapper 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.15/python/weka/core/utils.py 0000644 0172670 0172670 00000007205 12443672543 024102 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# utils.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
import weka.core.types as arrays
from weka.core.classes import OptionHandler
# logging setup
logger = logging.getLogger(__name__)
def get_class(classname):
"""
Returns the class object associated with the dot-notation classname.
Taken from here: http://stackoverflow.com/a/452981
:param classname: the classname
:type classname: str
:return: the class object
:rtype: object
"""
parts = classname.split('.')
module = ".".join(parts[:-1])
m = __import__(module)
for comp in parts[1:]:
m = getattr(m, comp)
return m
def split_options(cmdline):
"""
Splits the commandline into a list of options.
:param cmdline: the commandline string to split into individual options
:type cmdline: str
:return: the split list of commandline options
:rtype: list
"""
return arrays.string_array_to_list(
javabridge.static_call(
"Lweka/core/Utils;", "splitOptions",
"(Ljava/lang/String;)[Ljava/lang/String;",
cmdline))
def join_options(options):
"""
Turns the list of options back into a single commandline string.
:param options: the list of options to process
:type options: list
:return: the combined options
:rtype: str
"""
return javabridge.static_call(
"Lweka/core/Utils;", "joinOptions",
"([Ljava/lang/String;)Ljava/lang/String;",
options)
def to_commandline(optionhandler):
"""
Generates a commandline string from the OptionHandler instance.
:param optionhandler: the OptionHandler instance to turn into a commandline
:type optionhandler: OptionHandler
:return: the commandline string
:rtype: str
"""
return javabridge.static_call(
"Lweka/core/Utils;", "toCommandLine",
"(Ljava/lang/Object;)Ljava/lang/String;",
optionhandler.jobject)
def from_commandline(cmdline, classname=None):
"""
Creates an OptionHandler based on the provided commandline string.
:param cmdline: the commandline string to use
:type cmdline: str
:param classname: the classname of the wrapper to return other than OptionHandler (in dot-notation)
:type classname: str
:return: the generated option handler instance
:rtype: object
"""
params = split_options(cmdline)
cls = params[0]
params = params[1:]
handler = OptionHandler(jobject=javabridge.make_instance(cls.replace(".", "/"), "()V"), options=params)
if classname is None:
return handler
else:
c = get_class(classname)
return c(jobject=handler.jobject)
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.15/python/weka/core/dataset.py 0000644 0172670 0172670 00000111520 12444357065 024363 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# dataset.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
import numpy
from weka.core.classes import JavaObject
import weka.core.types as types
# logging setup
logger = logging.getLogger(__name__)
class Instances(JavaObject):
"""
Wrapper class for weka.core.Instances.
"""
def __init__(self, jobject):
"""
Initializes the weka.core.Instances wrapper.
:param jobject: the weka.core.Instances object to wrap
:type jobject: JB_Object
"""
self.enforce_type(jobject, "weka.core.Instances")
super(Instances, self).__init__(jobject)
def __iter__(self):
"""
Allows iterating over the rows.
:return: the iterator
:rtype: InstanceIterator
"""
return InstanceIterator(self)
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 attributes(self):
"""
Returns an iterator over the attributes.
"""
return AttributeIterator(self)
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 __iter__(self):
"""
Returns an iterator over the values.
:return: a value iterator
:rtype: InstanceValueIterator
"""
return InstanceValueIterator(self)
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, "setValue", "(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 nominal attribute.
:param name: the name of the attribute
:type name: str
:param labels: the list of string labels to use
:type labels: list
"""
return Attribute(
javabridge.make_instance(
"weka/core/Attribute", "(Ljava/lang/String;Ljava/util/List;)V", name, javabridge.make_list(labels)))
@classmethod
def create_string(cls, name):
"""
Creates a string attribute.
:param name: the name of the attribute
:type name: str
"""
return Attribute(
javabridge.make_instance(
"weka/core/Attribute", "(Ljava/lang/String;Ljava/util/List;)V", name, None))
class AttributeStats(JavaObject):
"""
Container for attribute statistics.
"""
def __init__(self, jobject):
"""
Initializes the container.
:param jobject: The Java object to wrap
:type jobject: JB_Object
"""
self.enforce_type(jobject, "weka.core.AttributeStats")
super(AttributeStats, self).__init__(jobject)
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")
class InstanceIterator(object):
"""
Iterator for rows in an Instances object.
"""
def __init__(self, data):
"""
:param data: the Instances object to iterate over
:type data: Instances
"""
self.data = data
self.row = 0
def __iter__(self):
"""
Returns itself.
"""
return self
def next(self):
"""
Returns the next row from the Instances object.
:return: the next Instance object
:rtype: Instance
"""
if self.row < self.data.num_instances():
index = self.row
self.row += 1
return self.data.get_instance(index)
else:
raise StopIteration()
class AttributeIterator(object):
"""
Iterator for attributes in an Instances object.
"""
def __init__(self, data):
"""
:param data: the Instances object to iterate over
:type data: Instances
"""
self.data = data
self.col = 0
def __iter__(self):
"""
Returns itself.
"""
return self
def next(self):
"""
Returns the next attribute from the Instances object.
:return: the next Attribute object
:rtype: Attribute
"""
if self.col < self.data.num_attributes():
index = self.col
self.col += 1
return self.data.get_attribute(index)
else:
raise StopIteration()
class InstanceValueIterator(object):
"""
Iterator for values in an Instance object.
"""
def __init__(self, data):
"""
:param data: the Instance object to iterate over
:type data: Instance
"""
self.data = data
self.col = 0
def __iter__(self):
"""
Returns itself.
"""
return self
def next(self):
"""
Returns the next value from the Instance object.
:return: the next value, depending on the attribute that can be either a number of a string
:rtype: str or float
"""
if self.col < self.data.num_attributes():
index = self.col
self.col += 1
if self.data.get_dataset().get_attribute(index).is_numeric():
return self.data.get_value(index)
else:
return self.data.get_string_value(index)
else:
raise StopIteration()
python-weka-wrapper-0.1.15/python/weka/core/converters.py 0000644 0172670 0172670 00000020237 12443672522 025131 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# converters.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
from weka.core.classes import OptionHandler
from weka.core.capabilities import Capabilities
from weka.core.dataset import Instances, Instance
class Loader(OptionHandler):
"""
Wrapper class for Loaders.
"""
def __init__(self, classname="weka.core.converters.ArffLoader", jobject=None, options=None):
"""
Initializes the specified loader either using the classname or the JB_Object.
:param classname: the classname of the loader
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: the list of commandline options to set
:type options: list
"""
if jobject is None:
jobject = Loader.new_instance(classname)
self.enforce_type(jobject, "weka.core.converters.Loader")
super(Loader, self).__init__(jobject=jobject, options=options)
self.incremental = False
self.structure = None
def __iter__(self):
"""
Returns an iterator in case the loader was instantiated in incremental mode, otherwise
an Exception is raised.
:return: the iterator
:rtype: IncrementalLoaderIterator
"""
if not self.incremental:
raise Exception("Not in incremental mode, cannot iterate!")
return IncrementalLoaderIterator(self, self.structure)
def load_file(self, dfile, incremental=False):
"""
Loads the specified file and returns the Instances object.
In case of incremental loading, only the structure.
:param dfile: the file to load
:type dfile: str
:param incremental: whether to load the dataset incrementally
:type incremental: bool
:return: the full dataset or the header (if incremental)
:rtype: Instances
"""
self.enforce_type(self.jobject, "weka.core.converters.FileSourcedConverter")
self.incremental = incremental
if not javabridge.is_instance_of(dfile, "Ljava/io/File;"):
dfile = javabridge.make_instance(
"Ljava/io/File;", "(Ljava/lang/String;)V", javabridge.get_env().new_string_utf(str(dfile)))
javabridge.call(self.jobject, "reset", "()V")
javabridge.call(self.jobject, "setFile", "(Ljava/io/File;)V", dfile)
if incremental:
self.structure = Instances(javabridge.call(self.jobject, "getStructure", "()Lweka/core/Instances;"))
return self.structure
else:
return Instances(javabridge.call(self.jobject, "getDataSet", "()Lweka/core/Instances;"))
def load_url(self, url, incremental=False):
"""
Loads the specified URL and returns the Instances object.
In case of incremental loading, only the structure.
:param url: the URL to load the data from
:type url: str
:param incremental: whether to load the dataset incrementally
:type incremental: bool
:return: the full dataset or the header (if incremental)
:rtype: Instances
"""
self.enforce_type(self.jobject, "weka.core.converters.URLSourcedLoader")
self.incremental = incremental
javabridge.call(self.jobject, "reset", "()V")
javabridge.call(self.jobject, "setURL", "(Ljava/lang/String;)V", str(url))
if incremental:
self.structure = Instances(javabridge.call(self.jobject, "getStructure", "()Lweka/core/Instances;"))
return self.structure
else:
return Instances(javabridge.call(self.jobject, "getDataSet", "()Lweka/core/Instances;"))
class IncrementalLoaderIterator(object):
"""
Iterator for dataset rows when loarding incrementally.
"""
def __init__(self, loader, structure):
"""
:param loader: the loader instance to use for loading the data incrementally
:type loader: Loader
:param structure: the dataset structure
:type structure: Instances
"""
self.loader = loader
self.structure = structure
def __iter__(self):
"""
Returns itself.
"""
return self
def next(self):
"""
Reads the next dataset row.
:return: the next row
:rtype: Instance
"""
result = javabridge.call(
self.loader.jobject, "getNextInstance",
"(Lweka/core/Instances;)Lweka/core/Instance;", self.structure.jobject)
if result is None:
raise StopIteration()
else:
return Instance(result)
class Saver(OptionHandler):
"""
Wrapper class for Savers.
"""
def __init__(self, classname="weka.core.converters.ArffSaver", jobject=None, options=None):
"""
Initializes the specified saver either using the classname or the provided JB_Object.
:param classname: the classname of the saver
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: the list of commandline options to use
:type options: list
"""
if jobject is None:
jobject = Saver.new_instance(classname)
self.enforce_type(jobject, "weka.core.converters.Saver")
super(Saver, self).__init__(jobject=jobject, options=options)
def 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.15/python/weka/core/jvm.py 0000644 0172670 0172670 00000007760 12443672527 023546 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# jvm.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import os
import glob
import logging
started = None
# logging setup
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
def add_bundled_jars():
"""
Adds the bundled jars to the JVM's classpath.
"""
# determine lib directory with jars
rootdir = os.path.split(os.path.dirname(__file__))[0]
libdir = rootdir + os.sep + "lib"
# add jars from lib directory
for l in glob.glob(libdir + os.sep + "*.jar"):
if l.lower().find("-src.") == -1:
javabridge.JARS.append(str(l))
def add_weka_packages():
"""
Adds the jars from all Weka packages to the JVM's classpath.
"""
prefix = os.getenv("WEKA_HOME", "~")
package_dir = os.path.expanduser(prefix + os.sep + "wekafiles" + os.sep + "packages")
logger.debug("package_dir=" + package_dir)
# traverse packages
for p in os.listdir(package_dir):
if os.path.isdir(package_dir + os.sep + p):
directory = package_dir + os.sep + p
logger.debug(" directory=" + directory)
# inspect package directory
for l in os.listdir(directory):
if l.lower().endswith(".jar"):
javabridge.JARS.append(directory + os.sep + l)
if l == "lib":
for m in glob.glob(directory + os.sep + "lib" + os.sep + "*.jar"):
javabridge.JARS.append(m)
def add_system_classpath():
"""
Adds the system's classpath to the JVM's classpath.
"""
if not os.environ['CLASSPATH'] is None:
parts = os.environ['CLASSPATH'].split(os.pathsep)
for part in parts:
javabridge.JARS.append(part)
def start(class_path=None, bundled=True, packages=False, system_cp=False, max_heap_size=None):
"""
Initializes the javabridge connection (starts up the JVM).
:param class_path: the additional classpath elements to add
:type class_path: str
:param bundled: whether to add jars from the "lib" directory
:type bundled: bool
:param packages: whether to add jars from Weka packages as well
:type packages: bool
:param system_cp: whether to add the system classpath as well
:type system_cp: bool
:param max_heap_size: the maximum heap size (-Xmx parameter, eg 512m or 4g)
:type max_heap_size: str
"""
global started
if not started is None:
logger.info("JVM already running, call jvm.stop() first")
return
# add user-defined jars first
if not class_path is None:
for cp in class_path:
logger.debug("Adding user-supplied classpath=" + cp)
javabridge.JARS.append(cp)
if bundled:
logger.debug("Adding bundled jars")
add_bundled_jars()
if packages:
logger.debug("Adding Weka packages")
add_weka_packages()
if system_cp:
logger.debug("Adding system classpath")
add_system_classpath()
logger.debug("Classpath=" + str(javabridge.JARS))
logger.debug("MaxHeapSize=" + ("default" if (max_heap_size is None) else max_heap_size))
javabridge.start_vm(run_headless=True, max_heap_size=max_heap_size)
javabridge.attach()
started = True
def stop():
""" Kills the JVM. """
global started
if not started is None:
started = None
javabridge.kill_vm()
python-weka-wrapper-0.1.15/python/weka/core/serialization.py 0000644 0172670 0172670 00000006131 12443672536 025616 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# serialization.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
from weka.core.classes import JavaObject
# logging setup
logger = logging.getLogger(__name__)
def read(filename):
"""
Reads the serialized object from disk. Caller must wrap object in appropriate Python wrapper class.
:param filename: the file with the serialized object
:type filename: str
:return: the JB_Object
:rtype: JB_Object
"""
return javabridge.static_call(
"Lweka/core/SerializationHelper;", "read",
"(Ljava/lang/String;)Ljava/lang/Object;",
filename)
def read_all(filename):
"""
Reads the serialized objects from disk. Caller must wrap objects in appropriate Python wrapper classes.
:param filename: the file with the serialized objects
:type filename: str
:return: the list of JB_OBjects
:rtype: list
"""
array = javabridge.static_call(
"Lweka/core/SerializationHelper;", "readAll",
"(Ljava/lang/String;)[Ljava/lang/Object;",
filename)
if array is None:
return None
else:
return javabridge.get_env().get_object_array_elements(array)
def write(filename, jobject):
"""
Serializes the object to disk. JavaObject instances get automatically unwrapped
:param filename: the file to serialize the object to
:type filename: str
:param jobject: the object to serialize
:type jobject: JB_Object or JavaObject
"""
if isinstance(jobject, JavaObject):
jobject = jobject.jobject
javabridge.static_call(
"Lweka/core/SerializationHelper;", "write",
"(Ljava/lang/String;Ljava/lang/Object;)V",
filename, jobject)
def write_all(filename, jobjects):
"""
Serializes the list of objects to disk. JavaObject instances get automatically unwrapped
:param filename: the file to serialize the object to
:type filename: str
:param jobjects: the list of objects to serialize
:type jobjects: list
"""
array = javabridge.get_env().make_object_array(len(jobjects), javabridge.get_env().find_class("java/lang/Object"))
for i in xrange(len(jobjects)):
obj = jobjects[i]
if isinstance(obj, JavaObject):
obj = obj.jobject
javabridge.get_env().set_object_array_element(array, i, obj)
javabridge.static_call(
"Lweka/core/SerializationHelper;", "writeAll",
"(Ljava/lang/String;[Ljava/lang/Object;)V",
filename, array)
python-weka-wrapper-0.1.15/python/weka/core/packages.py 0000644 0172670 0172670 00000025054 12443672532 024520 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# packages.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import weka.core.jvm as jvm
from weka.core.classes import JavaObject
class Package(JavaObject):
"""
Wrapper for the org.pentaho.packageManagement.Package class.
"""
def __init__(self, jobject):
"""
Initializes the wrapper.
:param jobject: the java Package instance to wrap
:type jobject: JB_Object
"""
self.enforce_type(jobject, "org.pentaho.packageManagement.Package")
super(Package, self).__init__(jobject)
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.15/python/weka/core/types.py 0000644 0172670 0172670 00000005755 12443672541 024114 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# types.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
import numpy
# logging setup
logger = logging.getLogger(__name__)
def string_array_to_list(a):
"""
Turns the Java string array into Python unicode string list.
:param a: the string array to convert
:type a: JB_Object
:return: the string list
:rtype: list
"""
result = []
length = javabridge.get_env().get_array_length(a)
wrapped = javabridge.get_env().get_object_array_elements(a)
for i in xrange(length):
result.append(javabridge.get_env().get_string(wrapped[i]))
return result
def string_list_to_array(l):
"""
Turns a Python unicode string list into a Java String array.
:param l: the string list
:type: list
:rtype: java string array
:return: JB_Object
"""
result = javabridge.get_env().make_object_array(len(l), javabridge.get_env().find_class("java/lang/String"))
for i in xrange(len(l)):
javabridge.get_env().set_object_array_element(result, i, javabridge.get_env().new_string_utf(l[i]))
return result
def double_matrix_to_ndarray(m):
"""
Turns the Java matrix (2-dim array) of doubles into a numpy 2-dim array.
:param m: the double matrix
:type: JB_Object
:return: Numpy array
:rtype: numpy.darray
"""
rows = javabridge.get_env().get_object_array_elements(m)
num = javabridge.get_env().get_array_length(m)
result = numpy.zeros(num * num).reshape((num, num))
i = 0
for row in rows:
elements = javabridge.get_env().get_double_array_elements(row)
n = 0
for element in elements:
result[i][n] = element
n += 1
i += 1
return result
def enumeration_to_list(enm):
"""
Turns the java,util.Enumeration into a list.
:param enm: the enumeration to convert
:type enm: JB_Object
:return: the list
:rtype: list
"""
result = []
while javabridge.call(enm, "hasMoreElements", "()Z"):
result.append(javabridge.call(enm, "nextElement", "()Ljava/lang/Object;"))
return result
def double_to_float(d):
"""
Turns the Python float into a Java java.lang.Float object.
:param d: the Python float
:type d: float
:return: the Float object
:rtype: JB_Object
"""
return javabridge.make_instance("java/lang/Float", "(D)V", d)
python-weka-wrapper-0.1.15/python/weka/core/capabilities.py 0000644 0172670 0172670 00000030536 12443672510 025370 0 ustar fracpete fracpete 0000000 0000000 # 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 (pythonwekawrapper 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.15/python/weka/core/__init__.py 0000644 0172670 0172670 00000000000 12322574641 024457 0 ustar fracpete fracpete 0000000 0000000 python-weka-wrapper-0.1.15/python/weka/classifiers.py 0000644 0172670 0172670 00000161235 12443672467 024332 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# classifiers.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import sys
import os
import javabridge
import logging
import argparse
import weka.core.jvm as jvm
import weka.core.utils as wutils
import weka.core.types as arrays
from numpy import *
from weka.core.classes import JavaObject
from weka.core.classes import OptionHandler
from weka.core.classes import Random
from weka.core.capabilities import Capabilities
from weka.core.dataset import Instances, Instance, Attribute
from weka.filters import Filter
# logging setup
logger = logging.getLogger("weka.classifiers")
class Classifier(OptionHandler):
"""
Wrapper class for classifiers.
"""
def __init__(self, classname=None, jobject=None, options=None):
"""
Initializes the specified classifier using either the classname or the supplied JB_Object.
:param classname: the classname of the classifier
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: the list of commandline options to set
:type options: list
"""
if jobject is None:
jobject = Classifier.new_instance(classname)
self.enforce_type(jobject, "weka.classifiers.Classifier")
self.is_updateable = self.check_type(jobject, "weka.classifiers.UpdateableClassifier")
self.is_drawable = self.check_type(jobject, "weka.core.Drawable")
super(Classifier, self).__init__(jobject=jobject, options=options)
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 Kernel(OptionHandler):
"""
Wrapper class for kernels.
"""
def __init__(self, classname=None, jobject=None, options=None):
"""
Initializes the specified kernel using either the classname or the supplied JB_Object.
:param classname: the classname of the kernel
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: the list of commandline options to set
:type options: list
"""
if jobject is None:
jobject = Classifier.new_instance(classname)
self.enforce_type(jobject, "weka.classifiers.functions.supportVector.Kernel")
super(Kernel, self).__init__(jobject=jobject, options=options)
def 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 set_checks_turned_off(self, off):
"""
Turns any checks on/off.
:param off: True to turn off checks
:type off: bool
"""
javabridge.call(self.jobject, "setChecksTurnedOff", "(Z)V", off)
def get_checks_turned_off(self):
"""
Returns whether checks are turned off.
:return: True if checks turned off
:rtype: bool
"""
return javabridge.call(self.jobject, "getChecksTurnedOff", "()Z")
def clean(self):
"""
Frees the memory used by the kernel.
"""
javabridge.call(self.jobject, "clean", "()V")
def build_kernel(self, data):
"""
Builds the classifier with the data.
:param data: the data to train the classifier with
:type data: Instances
"""
javabridge.call(self.jobject, "buildKernel", "(Lweka/core/Instances;)V", data.jobject)
def eval(self, id1, id2, inst1):
"""
Computes the result of the kernel function for two instances. If id1 == -1, eval use inst1 instead of an
instance in the dataset.
:param id1: the index of the first instance in the dataset
:type id1: int
:param id2: the index of the second instance in the dataset
:type id2: int
:param inst1: the instance corresponding to id1 (used if id1 == -1)
:type inst1: Instance
"""
jinst1 = None
if not inst1 is None:
jinst1 = inst1.jobject
return javabridge.call(self.jobject, "eval", "(IILweka/core/Instance;)D", id1, id2, jinst1)
@classmethod
def make_copy(cls, kernel):
"""
Creates a copy of the kernel.
:param kernel: the kernel to copy
:type kernel: Kernel
:return: the copy of the kernel
:rtype: Kernel
"""
return Kernel(
jobject=javabridge.static_call(
"weka/classifiers/functions/supportVector/Kernel", "makeCopy",
"(Lweka/classifiers/functions/supportVector/Kernel;)Lweka/classifiers/functions/supportVector/Kernel;",
kernel.jobject))
class KernelClassifier(Classifier):
"""
Wrapper class for classifiers that have a kernel property, like SMO.
"""
def __init__(self, classname=None, jobject=None, options=None):
"""
Initializes the specified classifier using either the classname or the supplied JB_Object.
:param classname: the classname of the classifier
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: list of commandline options
:type options: list
"""
if jobject is None:
jobject = Classifier.new_instance(classname)
self.enforce_type(jobject, "weka.classifiers.Classifier")
if not javabridge.static_call(
"weka/classifiers/KernelHelper", "hasKernelProperty",
"(Ljava/lang/Object;)Z",
jobject):
raise Exception("Does not handle a kernel: " + wutils.get_classname(jobject))
super(KernelClassifier, self).__init__(classname=classname, jobject=jobject, options=options)
def set_kernel(self, kernel):
"""
Sets the kernel.
:param kernel: the kernel to set
:type kernel: Kernel
:return: whether successfully set
:rtype: bool
"""
result = javabridge.static_call(
"weka/classifiers/KernelHelper", "setKernel",
"(Ljava/lang/Object;Lweka/classifiers/functions/supportVector/Kernel;)Z",
self.jobject, kernel.jobject)
return result
def get_kernel(self):
"""
Returns the current kernel.
:return: the kernel or None if none found
:rtype: Kernel
"""
result = javabridge.static_call(
"weka/classifiers/KernelHelper", "getKernel",
"(Ljava/lang/Object;)Lweka/classifiers/functions/supportVector/Kernel;",
self.jobject)
if result is None:
return None
else:
return Kernel(jobject=result)
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():
"""
Runs a classifier from the command-line. Calls JVM start/stop automatically.
Use -h to see all options.
"""
parser = argparse.ArgumentParser(
description='Performs classification/regression from the command-line. Calls JVM start/stop automatically.')
parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories")
parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m")
parser.add_argument("-t", metavar="train", dest="train", required=True, help="Training set file")
parser.add_argument("-T", metavar="test", dest="test", help="Test set file")
parser.add_argument("-c", metavar="class index", dest="classindex", help="1-based class attribute index")
parser.add_argument("-d", metavar="outmodel", dest="outmodel", help="model output file name")
parser.add_argument("-l", metavar="inmodel", dest="inmodel", help="model input file name")
parser.add_argument("-x", metavar="num folds", dest="numfolds", help="number of folds for cross-validation")
parser.add_argument("-s", metavar="seed", dest="seed", help="seed value for randomization")
parser.add_argument("-v", action="store_true", dest="notrainstats", help="no statistics for training")
parser.add_argument("-o", action="store_true", dest="onlystats", help="only statistics, don't output model")
parser.add_argument("-i", action="store_true", dest="irstats", help="output information retrieval statistics")
parser.add_argument("-k", action="store_true", dest="itstats", help="output information theoretic statistics")
parser.add_argument("-m", metavar="costmatrix", dest="costmatrix", help="cost matrix file")
parser.add_argument("-g", metavar="graph", dest="graph", help="output file for graph (if supported)")
parser.add_argument("classifier", help="classifier classname, e.g., weka.classifiers.trees.J48")
parser.add_argument("option", nargs=argparse.REMAINDER, help="additional ckassifier options")
parsed = parser.parse_args()
jars = []
if not parsed.classpath is None:
jars = parsed.classpath.split(os.pathsep)
params = []
if not parsed.train is None:
params.extend(["-t", parsed.train])
if not parsed.test is None:
params.extend(["-T", parsed.test])
if not parsed.classindex is None:
params.extend(["-c", parsed.classindex])
if not parsed.outmodel is None:
params.extend(["-d", parsed.outmodel])
if not parsed.inmodel is None:
params.extend(["-l", parsed.inmodel])
if not parsed.numfolds is None:
params.extend(["-x", parsed.numfolds])
if not parsed.seed is None:
params.extend(["-s", parsed.seed])
if parsed.notrainstats:
params.append("-v")
if parsed.onlystats:
params.append("-o")
if parsed.irstats:
params.append("-i")
if parsed.itstats:
params.append("-k")
if not parsed.costmatrix is None:
params.extend(["-m", parsed.costmatrix])
if not parsed.graph is None:
params.extend(["-g", parsed.graph])
jvm.start(jars, max_heap_size=parsed.heap, packages=True)
logger.debug("Commandline: " + wutils.join_options(sys.argv[1:]))
try:
classifier = Classifier(classname=parsed.classifier)
if len(parsed.option) > 0:
classifier.set_options(parsed.option)
print(Evaluation.evaluate_model(classifier, params))
except Exception, e:
print(e)
finally:
jvm.stop()
if __name__ == "__main__":
try:
main()
except Exception, ex:
print(ex)
python-weka-wrapper-0.1.15/python/weka/associations.py 0000644 0172670 0172670 00000007576 12443672462 024524 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# associations.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
import os
import sys
import argparse
import weka.core.jvm as jvm
import weka.core.utils as utils
import weka.core.converters as converters
from weka.core.classes import OptionHandler
from weka.core.capabilities import Capabilities
# logging setup
logger = logging.getLogger("weka.associations")
class Associator(OptionHandler):
"""
Wrapper class for associators.
"""
def __init__(self, classname=None, jobject=None, options=None):
"""
Initializes the specified associator using either the classname or the supplied JB_Object.
:param classname: the classname of the associator
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: the list of commandline options to set
:type options: list
"""
if jobject is None:
jobject = Associator.new_instance(classname)
self.enforce_type(jobject, "weka.associations.Associator")
super(Associator, self).__init__(jobject=jobject, options=options)
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():
"""
Runs a associator from the command-line. Calls JVM start/stop automatically.
Use -h to see all options.
"""
parser = argparse.ArgumentParser(
description='Executes an associator from the command-line. Calls JVM start/stop automatically.')
parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories")
parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m")
parser.add_argument("-t", metavar="train", dest="train", required=True, help="training set file")
parser.add_argument("associator", help="associator classname, e.g., weka.associations.Apriori")
parser.add_argument("option", nargs=argparse.REMAINDER, help="additional associator options")
parsed = parser.parse_args()
jars = []
if not parsed.classpath is None:
jars = parsed.classpath.split(os.pathsep)
jvm.start(jars, max_heap_size=parsed.heap, packages=True)
logger.debug("Commandline: " + utils.join_options(sys.argv[1:]))
try:
associator = Associator(classname=parsed.associator)
if len(parsed.option) > 0:
associator.set_options(parsed.option)
loader = converters.loader_for_file(parsed.train)
data = loader.load_file(parsed.train)
associator.build_associations(data)
print(str(associator))
except Exception, e:
print(e)
finally:
jvm.stop()
if __name__ == "__main__":
try:
main()
except Exception, ex:
print(ex)
python-weka-wrapper-0.1.15/python/weka/clusterers.py 0000644 0172670 0172670 00000032700 12443672474 024206 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# clusterers.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
import os
import sys
import argparse
import weka.core.jvm as jvm
import weka.core.utils as utils
from weka.core.classes import JavaObject
from weka.core.classes import OptionHandler
from weka.core.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():
"""
Runs a clusterer from the command-line. Calls JVM start/stop automatically.
Use -h to see all options.
"""
parser = argparse.ArgumentParser(
description='Performs clustering from the command-line. Calls JVM start/stop automatically.')
parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories")
parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m")
parser.add_argument("-t", metavar="train", dest="train", required=True, help="training set file")
parser.add_argument("-T", metavar="test", dest="test", help="test set file")
parser.add_argument("-d", metavar="outmodel", dest="outmodel", help="model output file name")
parser.add_argument("-l", metavar="inmodel", dest="inmodel", help="model input file name")
parser.add_argument("-p", metavar="attributes", dest="attributes", help="attribute range")
parser.add_argument("-x", metavar="num folds", dest="numfolds", help="number of folds")
parser.add_argument("-s", metavar="seed", dest="seed", help="seed value for randomization")
parser.add_argument("-c", metavar="class index", dest="classindex", help="1-based class attribute index")
parser.add_argument("-g", metavar="graph", dest="graph", help="graph output file (if supported)")
parser.add_argument("clusterer", help="clusterer classname, e.g., weka.clusterers.SimpleKMeans")
parser.add_argument("option", nargs=argparse.REMAINDER, help="additional clusterer options")
parsed = parser.parse_args()
jars = []
if not parsed.classpath is None:
jars = parsed.classpath.split(os.pathsep)
params = []
if not parsed.train is None:
params.extend(["-t", parsed.train])
if not parsed.test is None:
params.extend(["-T", parsed.test])
if not parsed.outmodel is None:
params.extend(["-d", parsed.outmodel])
if not parsed.inmodel is None:
params.extend(["-l", parsed.inmodel])
if not parsed.attributes is None:
params.extend(["-p", parsed.attributes])
if not parsed.numfolds is None:
params.extend(["-x", parsed.numfolds])
if not parsed.seed is None:
params.extend(["-s", parsed.seed])
if not parsed.classindex is None:
params.extend(["-c", parsed.classindex])
if not parsed.graph is None:
params.extend(["-g", parsed.graph])
jvm.start(jars, max_heap_size=parsed.heap, packages=True)
logger.debug("Commandline: " + utils.join_options(sys.argv[1:]))
try:
clusterer = Clusterer(classname=parsed.clusterer)
if len(parsed.option) > 0:
clusterer.set_options(parsed.option)
print(ClusterEvaluation.evaluate_clusterer(clusterer, params))
except Exception, e:
print(e)
finally:
jvm.stop()
if __name__ == "__main__":
try:
main()
except Exception, ex:
print(ex)
python-weka-wrapper-0.1.15/python/weka/attribute_selection.py 0000644 0172670 0172670 00000030355 12443672465 026067 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# attribute_selection.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
import argparse
import os
import sys
import weka.core.jvm as jvm
import weka.core.utils as utils
import weka.core.types as arrays
from weka.core.classes import JavaObject
from weka.core.classes import OptionHandler
from weka.core.capabilities import Capabilities
from weka.core.dataset import Instances, Instance
# logging setup
logger = logging.getLogger("weka.attribute_selection")
class ASSearch(OptionHandler):
"""
Wrapper class for attribute selection search algorithm.
"""
def __init__(self, classname=None, jobject=None, options=None):
"""
Initializes the specified search algorithm using either the classname or the supplied JB_Object.
:param classname: the classname of the search algorithms
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: the commandline options to use
:type options: list
"""
if jobject is None:
jobject = ASSearch.new_instance(classname)
self.enforce_type(jobject, "weka.attributeSelection.ASSearch")
super(ASSearch, self).__init__(jobject=jobject, options=options)
def search(self, evaluation, data):
"""
Performs the search and returns the indices of the selected attributes.
:param evaluation: the evaluation algorithm to use
:type evaluation: ASEvaluation
:param data: the data to use
:type data: Instances
:return: the selected attributes (0-based indices)
:rtype: ndarray
"""
array = javabridge.call(
self.jobject, "search", "(Lweka/attributeSelection/ASEvaluation;Lweka/core/Instances;)[I",
evaluation.jobject, data.jobject)
if array is None:
return None
else:
javabridge.get_env().get_int_array_elements(array)
class ASEvaluation(OptionHandler):
"""
Wrapper class for attribute selection evaluation algorithm.
"""
def __init__(self, classname=None, jobject=None, options=None):
"""
Initializes the specified search algorithm using either the classname or the supplied JB_Object.
:param classname: the classname of the search algorithms
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: the list of commandline options to set
:type options: list
"""
if jobject is None:
jobject = ASEvaluation.new_instance(classname)
self.enforce_type(jobject, "weka.attributeSelection.ASEvaluation")
super(ASEvaluation, self).__init__(jobject=jobject, options=options)
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():
"""
Runs attribute selection from the command-line. Calls JVM start/stop automatically.
Use -h to see all options.
"""
parser = argparse.ArgumentParser(
description='Performs attribute selection from the command-line. Calls JVM start/stop automatically.')
parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories")
parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m")
parser.add_argument("-i", metavar="input", dest="input", required=True, help="input file")
parser.add_argument("-c", metavar="class index", dest="classindex", help="1-based class attribute index")
parser.add_argument("-s", metavar="search", dest="search", help="search method, classname and options")
parser.add_argument("-x", metavar="num folds", dest="numfolds", help="number of folds")
parser.add_argument("-n", metavar="seed", dest="seed", help="the seed value for randomization")
parser.add_argument("evaluator", help="evaluator classname, e.g., weka.attributeSelection.CfsSubsetEval")
parser.add_argument("option", nargs=argparse.REMAINDER, help="additional evaluator options")
parsed = parser.parse_args()
jars = []
if not parsed.classpath is None:
jars = parsed.classpath.split(os.pathsep)
params = []
if not parsed.input is None:
params.extend(["-i", parsed.input])
if not parsed.classindex is None:
params.extend(["-c", parsed.classindex])
if not parsed.search is None:
params.extend(["-s", parsed.search])
if not parsed.numfolds is None:
params.extend(["-x", parsed.numfolds])
if not parsed.seed is None:
params.extend(["-n", parsed.seed])
jvm.start(jars, max_heap_size=parsed.heap, packages=True)
logger.debug("Commandline: " + utils.join_options(sys.argv[1:]))
try:
evaluation = ASEvaluation(classname=parsed.evaluator)
if len(parsed.option) > 0:
evaluation.set_options(parsed.option)
print(AttributeSelection.attribute_selection(evaluation, params))
except Exception, e:
print(e)
finally:
jvm.stop()
if __name__ == "__main__":
try:
main()
except Exception, ex:
print(ex)
python-weka-wrapper-0.1.15/python/weka/lib/ 0000755 0172670 0172670 00000000000 12444361245 022175 5 ustar fracpete fracpete 0000000 0000000 python-weka-wrapper-0.1.15/python/weka/lib/python-weka-wrapper.jar 0000644 0172670 0172670 00000005734 12424564746 026641 0 ustar fracpete fracpete 0000000 0000000 PK Çu_E META-INF/þÊ PK PK Çu_E META-INF/MANIFEST.MFóMÌËLK-.Ñ
K-*ÎÌϳR0Ô3àår.JM,IMÑuª ˜ëÄ›˜*hø%&ç¤*8çä%– •kòrñr PKXEC D PK
Çu_E weka/PK
Çu_E weka/classifiers/PK Çu_E # weka/classifiers/KernelHelper.classÍVisE~z¯ÙL¹ À&$,—.×&`Â!D‘Éî$L²;³ÌN8Ä AKD¿XåY¨¤TDåÃ¥¤¬ÒÂ*«üúÉ¿`YƧw³dsp}#[éî·ß£Ÿ÷è·ç÷ÿ~¼
`)ÞSQ†F9lP±M¥Ø„Í*¶`« ¶©ˆ¡YA‹‚í%ØgƒhUц*J°KE
v+Ø#…ž boû´«˜ˆFÏ«¨D£TzAÁ~SÑÄ‹r> BG‡\ŃHH#†$:ƒè’ÄA&ºƒè‘DRAJÅ|iÐR–³-XmZ¦»VÀ®Þ-àk´†@YÌ´Œ–ÞT‡áìÔ;’Ü™Ðe¸Û Ç2’; ;m8î1eáX·~X$u«+²½£Ûˆ»õÕùC·2‘‚è#wÌ´k;õãÚ\=ÞÓ¬§s–鳂´‚C
F† Ô3#ª ë }%™(¦1dbGŒ =OꙌÙiN&ÒÙkÅ]Ó&¶Lo:m;înÊÙN$o…F™ Úí²»qL' Õ0#›ÒMK`r¸½È^›ë˜VW½Œ¼ºñhÜHçLh³{¸ÑdæBŸ·±ÙH2 ‹¤²†…¨Õ« WÃa a 5 Å1ÆRÃK8®áe WðŠ†Wá
D ¯ÀÄ!w)xMÃë8!° I'´DȵCiÇŽ™ŒœsÙ
%î&;Uð††“8¥áM 8‚Åå#éá4Î0ÉC6™ÖPOHtØ~WñþÒ‡ö©µ¡©àÖ¬û(µ5o×ð–toÊÈ 5ôšÉ„áøÕººµ!
gqNÁy
pQÃÛ¸( ±nÁ£ÀÓX)¥. ss5Ö(xGÃe¼K…!/¥Â*Ч9÷‡ç]ÓFɸŽad"[—¯˜9ŠY\<äß÷vÒžç7pÜbu²I„Ú x«ƒÌM£<–6ÂÕE%žÛ¬/Ä4oa‹å:v&ËŽ@)U‡Î
‡G)ë)IšœLÅÑ`ˆ`n¸úÁˆÇS{cºF³á ´3†ávŒÎ$Fò\Ù·(ßj艂øÔ{ÉDÝ^ÇÚy,m +ù¶c×H±Ý]¯Ì hÚ„hZ.‹ÍÐSõ…4 ßPÒ’JZ#bQ)KçåÙ`w:zœGLë°ÝÃŪ1úXû=ûwñÁÚ½l"=6,ºW7Ö飶ï ÕËF$”ž0@-zŠ°&…GkÊrríüZ¦eß}ç+ÞvŒÈ.×LÒø8×n´S)ÝJÈWL`þ½Ÿ©âC1‡dä_ BvXŽu¤frœý57!¾çB`Ñ øŽ–ȶ–³á!
±š,<ýð6×þ Ÿ@K]Ô_忽"à]¡T*•+¨¯òW*K£Áª`þ;˜/çÀoôazn™…õUù&"x%UÁX JN)¢oà×>LŠúEìÔŠÒ,´*ã~G ´c?÷äà5aǤVAE”T=ý[ÍÕþÖòÛd ¶c=Zñ v‘×Îo”ýül9@Ír»±6¶a lF` 3T°TÁ2Ë<þ Fà_„¸÷¦ Àß0 ðtO~ BÁŠr¢cc ŒëâÁ¸Ž«éÇø;P|}ðy¯qÃSß]9 ~xJ×ó]–]rPû
¤‡Þ5R¿¥îjëJ´ßO(Ûë]Ø–Eù ßš>TDý2^
ñšqVJ1óîÆki Aª“®u‘2³n„ÐC¹4%SX ‹É¶±œO¯„5ž2ò^׋‚›ãi”~èex‰ Xš ÐæÚ;XPË·ÔÕx “†LoEÔ'1VHŒ¾BNKY}¡»k˜Ià©“ÄxŠÜÓ(ÇÊ\ ÔYââUÿ˜åþ ËéS\Å\ÇgøŸão|!‚¸*æ¡OlÀ—"†¯D¾gpM\Å7â\â[¶°”ä%l)ò7üPKYkH
PK Çu_E ( weka/classifiers/EvaluationWrapper.class…’]OA†ßi Cë"壀B¥Ti·¥eAåB«øA Ñ´hR¢ñÊL—‘,´»ÍîQ/ü9ÞªQšhâðG©g¶Å–ØàÅÎì¼gæ=Ïœ9?}ûà:ÖcÐä¸C Q\@Šc1Š4®ŽàZ KÈÄ0„¬
ë 9Ž<ƒÖx¹u$ê-á[ŽÍ,¿–‡Â0ëÂó¬W–t=£.1 ß±lËß`˜Õ»; Wl϶)½RîCdÓÙ“ ceË–;FMº»¢V'e´ê ó°"šÁ: X&B†õÁfÿ²l:ž_¾k S&ŽyîK¿ÿ zî?WˆU–kÊmK!M÷BÏ]ÑlJwå@
c(2Ì㤶Ä5Œâ"ä:cÔ…½ol ›²©â + ¬2d·åÚKùNJÏuëLõœRNí@šþmŽ5žñ††›(*û†ô9]`†x/ý“ÀŠˆÔsÐ}zeëêõú̪o<_6( ]Ê’(Ë1žº–íW}WŠFéôògeÞT«:½HB/÷YR*{?h“±fg?µÄ®+L‰EêX:™:H••þÂôOU¦qœVïHӜɷÁòßz±ÜFø+" ¨|Æð?ÁHáÑ<#ñSàÇ$µ|t.uRó¤¯R¤€)1¤è©–°Fè ýVÇGŒcz< ™é‚¼'ËÍÙ H¡X‡d甤x–dœr%¹Ej‰ô¹K‰6Ä=ªÂ}dð0 ™V$SwH8fÿÂ\Âå.L’fFóPþ " ƒò©Ãø˜Æ9šC˜ÿPKÇNcY ' PK Çu_E META-INF/þÊ PK Çu_EXEC D = META-INF/MANIFEST.MFPK
Çu_E Â weka/PK
Çu_E å weka/classifiers/PK Çu_EYkH
# weka/classifiers/KernelHelper.classPK Çu_EÇNcY ' ( weka/classifiers/EvaluationWrapper.classPK – 0
python-weka-wrapper-0.1.15/python/weka/lib/python-weka-wrapper-src.jar 0000644 0172670 0172670 00000006114 12424564746 027417 0 ustar fracpete fracpete 0000000 0000000 PK Çu_E META-INF/þÊ PK PK Çu_E META-INF/MANIFEST.MFóMÌËLK-.Ñ
K-*ÎÌϳR0Ô3àår.JM,IMÑuª ˜ëÄ›˜*hø%&ç¤*8çä%– •kòrñr PKXEC D PK
蚎D weka/PK
Š]_E weka/classifiers/PK Du_E " weka/classifiers/KernelHelper.javaíWMsÛ6=K¿b›K©Ô¡’6‡ŽU§qT+QãØ InÆ“ú ‘K
1p Pª&ñï %Ú¢l§“ô” %»ûñ v ·á1Lf\C®dªØ èo¢AËÄ,™Â}XÉ"&@a̵Q|Zn€‰¸+ÌeÌ“•Å¡±BĨÀÌ ª¹™¸—×'çð*–ÁY1ÍxÇ
ÆhÃB pG‰×%*cŒ†ñLW‰_Pc5E—Å0c ¤GȃHæ«û›gAX&EêÒ$ãM!)¸aBš=Ðäo3còýnw¹\†©(B©ÒnæAt÷…
¨Ûnw]ToQ ÌÞ`–£
?²³ƒ}ŠGñtf èwàç§ÏžCX”#Q1HªÔŸtNB,
¥0ïxÜœEW,EXâ £ŒiÍN èµÛÔ
© ØeÂ)2¡ÃWô ŠDöæ†Â(©sŒŒTMógŠx¢ÌêÔ‘âù–UÆD*L2Bß!1#ÞÄp;º0)Dd©«Ãñ»ÓÞÃ̦±ÔEnMþr™„¾â_î7z5¸ÏÕŒuøçó_o™ÃsC\ìÙ¶»¾ûŽƒóv”½rØk¶¾dL¹¾Ÿ=¤ï¹çª¬³
>µÛ nY àšB í¸ $\iÓ)׶dv
¤ § mëÀ9zï—9³ûÍÔ,ÀHHѸ‘ÛP‰’óÒU¹•›¬ö@´Ëð¤Œ%jñ£ñB• B—že–ÚÐöÁ6m >ùj.8õ„Ü¡RPƒ[«¥P™é¹ùJV‹;m4;}¸lÙ´ŸïÛ“G”•îáaáÀ%X7jU`× 2©ë-¤<ª0
ݾ»‚N§Wú¹ÅÉÏúÛùíɺ2¶ êeAö=”-O‹zöÕ"¾WÜ WnПE>†µÉY¼eÑi·€˜) öÚ¶&g“‹·¼˜¬r´áºœÃAIc/1] gG¦
Ùý».3õ¿þ1Í 8ú'Bw.vÖeoh
1+mp ¢Ra®¸0™
HktLÉi͵ް;Þ”zÿѺÖè}džvâ ©«6\׉áÄ°¡Ýõ
•ög]iXÎÐ ÿV3´è‚ÇH©‘Ý%XY"°;ò:¬ð!‚ì
·”©
´"¬úEnÉu‡§Rf6 ò¹W‚åŠÁ¶\Ñ%‘¶ 3F£k[ȃRÕ7÷¦Ä^™jåpÍÂûì.Ni¶¤âXl]D–t=Êî«®òÕd¯j¢‡JTºÜÜš¶./;éEÕj-l›6¡„eº>a]i¸¹ ÞΪљU-YëÇoa~±šºoì½r>äb!¯0pÙ
\‚ÏþÃå'Ÿóµµ\‡iK]i©Ru³’[wëÕ6Ç/àÔÙÚ)Ì›»Æ.º™5_71¾ì˜¼ëtÜ ŠÉ:!9¥+ØÁ±’EiŪ®ù‰ÿ@)Úcã k_ƒPv)€ çE&ÁÛR/ÖcÞ^v¾
•ÒoI¥ Ä5 —)Ýv²U—˜Ju‹n{sú͸@7 O€§‚®—ñN,$.‹"ÓWžH?\:¿ñLÉ¥†Mê©èyà*¹¾øV)ö×W^°· ØdêzëD·s2_O”Å¥oÃMqÿOž¼€Gð“u«]pìß6ÇõU§ÉÙ L>Êß Äö¡C w”ÍtÎîn Ù÷å=¦ònN&tÒf—ñ¡èºç^µ«õP¶ NŸCßkþÖœ¾ô¾üüº}ÝþPK†®„Ì µ PK /[¶D ' weka/classifiers/EvaluationWrapper.javaÕT]oÛ6}÷¯8È“ Òúñ”lC½Àn
¤‰a;ò4ÐÒ•ÅV"’²êù､$Ûi¶¶Ø°‡½¤xïáù¸t|>À9Ö¹´¨ŒÞQ‚—™!‚Õ™k„¡ ìuD(J¥uFnjGB¥±6(u*³½ÇáoµJÉÀåG¦´ÐYؼ½¹Ã[RdDE½)d‚k™²ÁWû/6§›€ã;fžÃªã€™f`á¤Vcäsƒ Ë{¼êïè ÇÐƃ …óÌ
tåûFLwB¸ckÄe%ÿ¨2…T;×+Ê’56²(°!Ô–²º{.Æý|ýîönÉÍî'ËåäfýpÉÅ.×|J;j¡dY’‘Y—Ê홾Gx?]^½ã–É óëùúE`6_ßLW+Ìn—˜`1Y®çWwד%wËÅíj+ò´È|Çâ,¤Ä6¦ä„,l/üƒµÌ®H‘‹ qÀ É sHtµÿqx DZmƒL.>Éäæ”vcX&ùkî\uÇMÓD[UGÚl㢱ñïžP<ÄÕt'Š:d}oDU‘‰>ˆð'WLÊÈmî0¼áå//^󘈤"žÇaÖ¯8¤mÉ2‘jÇ:ÊQ ^‰ä£Øú(¢¤ÖÊLò \ ‰6®;aŸ¢¹²N¨„üa| Xu\:©z{Î\ntc1ý”Pµ3_ÄÃÑO¢ÎÔ‰Ó¦wþ¨Àú‹Ÿ¡_µ¾··?s_€™†ûšð1å‘ëË 7 (q‘G‚OÈñŽ+Ž@(ÿ.
# filters.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
import os
import sys
import argparse
import weka.core.jvm as jvm
import weka.core.utils as utils
from weka.core.classes import OptionHandler
from weka.core.capabilities import Capabilities
from weka.core.converters import Loader
from weka.core.converters import Saver
from weka.core.dataset import Instances
from weka.core.dataset import Instance
# logging setup
logger = logging.getLogger("weka.filters")
class Filter(OptionHandler):
"""
Wrapper class for filters.
"""
def __init__(self, classname=None, jobject=None, options=None):
"""
Initializes the specified filter using either the classname or the supplied JB_Object.
:param classname: the classname of the filter
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
:param options: the list of commandline options to set
:type options: list
"""
if jobject is None:
jobject = Filter.new_instance(classname)
self.enforce_type(jobject, "weka.filters.Filter")
super(Filter, self).__init__(jobject=jobject, options=options)
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():
"""
Runs a filter from the command-line. Calls JVM start/stop automatically.
Use -h to see all options.
"""
parser = argparse.ArgumentParser(
description='Executes a filter from the command-line. Calls JVM start/stop automatically.')
parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories")
parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m")
parser.add_argument("-i", metavar="input1", dest="input1", required=True, help="input file 1")
parser.add_argument("-o", metavar="output1", dest="output1", required=True, help="output file 1")
parser.add_argument("-r", metavar="input2", dest="input2", help="input file 2")
parser.add_argument("-s", metavar="output2", dest="output2", help="output file 2")
parser.add_argument("-c", metavar="classindex", default="-1", dest="classindex", help="1-based class attribute index")
parser.add_argument("filter", help="filter classname, e.g., weka.filters.AllFilter")
parser.add_argument("option", nargs=argparse.REMAINDER, help="additional filter options")
parsed = parser.parse_args()
if parsed.input2 is None and not parsed.output2 is None:
raise Exception("No second input file provided ('-r ...')!")
jars = []
if not parsed.classpath is None:
jars = parsed.classpath.split(os.pathsep)
params = []
if not parsed.input1 is None:
params.extend(["-i", parsed.input1])
if not parsed.output1 is None:
params.extend(["-o", parsed.output1])
if not parsed.input2 is None:
params.extend(["-r", parsed.input2])
if not parsed.output2 is None:
params.extend(["-s", parsed.output2])
if not parsed.classindex is None:
params.extend(["-c", parsed.classindex])
jvm.start(jars, max_heap_size=parsed.heap, packages=True)
logger.debug("Commandline: " + utils.join_options(sys.argv[1:]))
try:
flter = Filter(parsed.filter)
if len(parsed.option) > 0:
flter.set_options(parsed.option)
loader = Loader(classname="weka.core.converters.ArffLoader")
in1 = loader.load_file(parsed.input1)
cls = parsed.classindex
if str(parsed.classindex) == "first":
cls = "0"
if str(parsed.classindex) == "last":
cls = str(in1.num_attributes() - 1)
in1.set_class_index(int(cls))
flter.set_inputformat(in1)
out1 = flter.filter(in1)
saver = Saver(classname="weka.core.converters.ArffSaver")
saver.save_file(out1, parsed.output1)
if not parsed.input2 is None:
in2 = loader.load_file(parsed.input2)
in2.set_class_index(int(cls))
out2 = flter.filter(in2)
saver.save_file(out2, parsed.output2)
except Exception, e:
print(e)
finally:
jvm.stop()
if __name__ == "__main__":
try:
main()
except Exception, ex:
print(ex)
python-weka-wrapper-0.1.15/python/weka/plot/ 0000755 0172670 0172670 00000000000 12444361245 022405 5 ustar fracpete fracpete 0000000 0000000 python-weka-wrapper-0.1.15/python/weka/plot/dataset.py 0000644 0172670 0172670 00000013235 12443672557 024422 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# dataset.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import logging
import weka.plot as plot
if plot.matplotlib_available:
import matplotlib.pyplot as plt
from weka.core.dataset import Instances
# logging setup
logger = logging.getLogger(__name__)
def scatter_plot(data, index_x, index_y, percent=100.0, seed=1, size=50, title=None, outfile=None, wait=True):
"""
Plots two attributes against each other.
TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html
:param data: the dataset
:type data: Instances
:param index_x: the 0-based index of the attribute on the x axis
:type index_x: int
:param index_y: the 0-based index of the attribute on the y axis
:type index_y: int
:param percent: the percentage of the dataset to use for plotting
:type percent: float
:param seed: the seed value to use for subsampling
:type seed: int
:param size: the size of the circles in point
:type size: int
:param title: an optional title
:type title: str
:param outfile: the (optional) file to save the generated plot to. The extension determines the file format.
:type outfile: str
:param wait: whether to wait for the user to close the plot
:type wait: bool
"""
if not plot.matplotlib_available:
logger.error("Matplotlib is not installed, plotting unavailable!")
return
# create subsample
data = plot.create_subsample(data, percent=percent, seed=seed)
# collect data
x = []
y = []
if data.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.15/python/weka/plot/classifiers.py 0000644 0172670 0172670 00000022131 12443672552 025272 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# classifiers.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
import weka.plot as plot
if plot.matplotlib_available:
import matplotlib.pyplot as plt
from weka.core.classes import JavaObject
from weka.core.dataset import Instances
from weka.classifiers import NumericPrediction, NominalPrediction
# logging setup
logger = logging.getLogger(__name__)
def plot_classifier_errors(predictions, absolute=True, max_relative_size=50, absolute_size=50, title=None,
outfile=None, wait=True):
"""
Plots the classifers for the given list of predictions.
TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html
:param predictions: the predictions to plot
:type predictions: list
:param absolute: whether to use absolute errors as size or relative ones
:type absolute: bool
:param max_relative_size: the maximum size in point in case of relative mode
:type max_relative_size: int
:param absolute_size: the size in point in case of absolute mode
:type absolute_size: int
:param title: an optional title
:type title: str
:param outfile: the output file, ignored if None
:type outfile: str
:param wait: whether to wait for the user to close the plot
:type wait: bool
"""
if not plot.matplotlib_available:
logger.error("Matplotlib is not installed, plotting unavailable!")
return
actual = []
predicted = []
error = None
cls = None
for pred in predictions:
actual.append(pred.actual())
predicted.append(pred.predicted())
if isinstance(pred, NumericPrediction):
if error is None:
error = []
error.append(abs(pred.error()))
elif isinstance(pred, NominalPrediction):
if cls is None:
cls = []
if pred.actual() != pred.predicted():
cls.append(1)
else:
cls.append(0)
fig, ax = plt.subplots()
if error is None and cls is None:
ax.scatter(actual, predicted, s=absolute_size, alpha=0.5)
elif not cls is None:
ax.scatter(actual, predicted, c=cls, s=absolute_size, alpha=0.5)
elif not error is None:
if not absolute:
min_err = min(error)
max_err = max(error)
factor = (max_err - min_err) / max_relative_size
for i in xrange(len(error)):
error[i] = error[i] / factor * max_relative_size
ax.scatter(actual, predicted, s=error, alpha=0.5)
ax.set_xlabel("actual")
ax.set_ylabel("predicted")
if title is None:
title = "Classifier errors"
ax.set_title(title)
ax.plot(ax.get_xlim(), ax.get_ylim(), ls="--", c="0.3")
ax.grid(True)
fig.canvas.set_window_title(title)
plt.draw()
if not outfile is None:
plt.savefig(outfile)
if wait:
plt.show()
def generate_thresholdcurve_data(evaluation, class_index):
"""
Generates the threshold curve data from the evaluation object's predictions.
:param evaluation: the evaluation to obtain the predictions from
:type evaluation: Evaluation
:param class_index: the 0-based index of the class-label to create the plot for
:type class_index: int
:return: the generated threshold curve data
:rtype: Instances
"""
jtc = JavaObject.new_instance("weka.classifiers.evaluation.ThresholdCurve")
pred = javabridge.call(evaluation.jobject, "predictions", "()Ljava/util/ArrayList;")
result = Instances(
javabridge.call(jtc, "getCurve", "(Ljava/util/ArrayList;I)Lweka/core/Instances;", pred, class_index))
return result
def get_thresholdcurve_data(data, xname, yname):
"""
Retrieves x and y columns from of the data generated by the weka.classifiers.evaluation.ThresholdCurve
class.
:param data: the threshold curve data
:type data: Instances
:param xname: the name of the X column
:type xname: str
:param yname: the name of the Y column
:type yname: str
:return: tuple of x and y arrays
:rtype: tuple
"""
xi = data.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=None, title=None, key_loc="lower right", outfile=None, wait=True):
"""
Plots the ROC (receiver operator characteristics) curve for the given predictions.
TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html
:param evaluation: the evaluation to obtain the predictions from
:type evaluation: Evaluation
:param class_index: the list of 0-based indices of the class-labels to create the plot for
:type class_index: list
:param title: an optional title
:type title: str
:param key_loc: the position string for the key
:type key_loc: str
:param outfile: the output file, ignored if None
:type outfile: str
:param wait: whether to wait for the user to close the plot
:type wait: bool
"""
if not plot.matplotlib_available:
logger.error("Matplotlib is not installed, plotting unavailable!")
return
if class_index is None:
class_index = [0]
ax = None
for cindex in class_index:
data = generate_thresholdcurve_data(evaluation, cindex)
head = evaluation.header()
area = get_auc(data)
x, y = get_thresholdcurve_data(data, "False Positive Rate", "True Positive Rate")
if ax is None:
fig, ax = plt.subplots()
ax.set_xlabel("False Positive Rate")
ax.set_ylabel("True Positive Rate")
if title is None:
title = "ROC"
ax.set_title(title)
ax.grid(True)
fig.canvas.set_window_title(title)
plt.xlim([-0.05, 1.05])
plt.ylim([-0.05, 1.05])
plot_label = head.get_class_attribute().value(cindex) + " (AUC: %0.4f)" % area
ax.plot(x, y, label=plot_label)
ax.plot(ax.get_xlim(), ax.get_ylim(), ls="--", c="0.3")
plt.draw()
plt.legend(loc=key_loc, shadow=True)
if not outfile is None:
plt.savefig(outfile)
if wait:
plt.show()
def plot_prc(evaluation, class_index=None, title=None, key_loc="lower center", outfile=None, wait=True):
"""
Plots the PRC (precision recall) curve for the given predictions.
TODO: click events http://matplotlib.org/examples/event_handling/data_browser.html
:param evaluation: the evaluation to obtain the predictions from
:type evaluation: Evaluation
:param class_index: the list of 0-based indices of the class-labels to create the plot for
:type class_index: list
:param title: an optional title
:type title: str
:param key_loc: the location string for the key
:type key_loc: str
:param outfile: the output file, ignored if None
:type outfile: str
:param wait: whether to wait for the user to close the plot
:type wait: bool
"""
if not plot.matplotlib_available:
logger.error("Matplotlib is not installed, plotting unavailable!")
return
if class_index is None:
class_index = [0]
ax = None
for cindex in class_index:
data = generate_thresholdcurve_data(evaluation, cindex)
head = evaluation.header()
x, y = get_thresholdcurve_data(data, "Recall", "Precision")
if ax is None:
fig, ax = plt.subplots()
ax.set_xlabel("Recall")
ax.set_ylabel("Precision")
if title is None:
title = "PRC"
ax.set_title(title)
fig.canvas.set_window_title(title)
plt.xlim([-0.05, 1.05])
plt.ylim([-0.05, 1.05])
ax.grid(True)
plot_label = head.get_class_attribute().value(cindex)
ax.plot(x, y, label=plot_label)
ax.plot(ax.get_xlim(), ax.get_ylim(), ls="--", c="0.3")
plt.draw()
plt.legend(loc=key_loc, shadow=True)
if not outfile is None:
plt.savefig(outfile)
if wait:
plt.show()
python-weka-wrapper-0.1.15/python/weka/plot/clusterers.py 0000644 0172670 0172670 00000007256 12443672554 025173 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# clusterers.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import 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.15/python/weka/plot/graph.py 0000644 0172670 0172670 00000003256 12443672561 024073 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# graph.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import logging
import tempfile
import weka.plot as plot
if plot.pygraphviz_available:
from pygraphviz.agraph import AGraph
if plot.PIL_available:
from PIL import Image
# logging setup
logger = logging.getLogger(__name__)
def plot_dot_graph(graph, filename=None):
"""
Plots a graph in graphviz dot notation.
:param graph: the dot notation graph
:type graph: str
:param filename: the (optional) file to save the generated plot to. The extension determines the file format.
:type filename: str
"""
if not plot.pygraphviz_available:
logger.error("Pygraphviz is not installed, cannot generate graph plot!")
return
if not plot.PIL_available:
logger.error("PIL is not installed, cannot display graph plot!")
return
agraph = AGraph(graph)
agraph.layout(prog='dot')
if filename is None:
filename = tempfile.mktemp(suffix=".png")
agraph.draw(filename)
image = Image.open(filename)
image.show()
python-weka-wrapper-0.1.15/python/weka/plot/__init__.py 0000644 0172670 0172670 00000003374 12443672546 024535 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# __init__.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
from weka.core.dataset import Instances
from weka.core.classes import Random
# check whether pygraphviz is there
pygraphviz_available = False
try:
import pygraphviz
pygraphviz_available = True
except ImportError:
pass
# check whether PIL is there
PIL_available = False
try:
import PIL
PIL_available = True
except ImportError:
pass
# check whether matplotlib is there
matplotlib_available = False
try:
import matplotlib
matplotlib_available = True
except ImportError:
pass
def create_subsample(data, percent, seed=1):
"""
Generates a subsample of the dataset.
:param data: the data to create the subsample from
:type data: Instances
:param percent: the percentage (0-100)
:type percent: float
:param seed: the seed value to use
:type seed: int
"""
if percent <= 0 or percent >= 100:
return data
data = Instances.copy_instances(data)
data.randomize(Random(seed))
data = Instances.copy_instances(data, 0, int(round(data.num_instances() * percent / 100.0)))
return data
python-weka-wrapper-0.1.15/python/weka/__init__.py 0000644 0172670 0172670 00000000000 12322574641 023527 0 ustar fracpete fracpete 0000000 0000000 python-weka-wrapper-0.1.15/python/weka/datagenerators.py 0000644 0172670 0172670 00000014200 12443672477 025014 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# datagenerators.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import javabridge
import logging
import os
import sys
import argparse
import weka.core.jvm as jvm
import weka.core.utils as utils
from weka.core.classes import OptionHandler
from weka.core.dataset import Instances, Instance
# logging setup
logger = logging.getLogger("weka.datagenerators")
class DataGenerator(OptionHandler):
"""
Wrapper class for datagenerators.
"""
def __init__(self, classname=None, jobject=None, options=None):
"""
Initializes the specified datagenerator using either the classname or the supplied JB_Object.
:param classname: the classname of the datagenerator
:type classname: str
:param jobject: the JB_Object to use
:type jobject: JB_Object
"""
if jobject is None:
jobject = DataGenerator.new_instance(classname)
self.enforce_type(jobject, "weka.datagenerators.DataGenerator")
super(DataGenerator, self).__init__(jobject=jobject, options=options)
def define_data_format(self):
"""
Returns the data format.
:return: the data format
:rtype: Instances
"""
data = javabridge.call(self.jobject, "defineDataFormat", "()Lweka/core/Instances;")
if data is None:
return None
else:
return Instances(data)
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():
"""
Runs a datagenerator from the command-line. Calls JVM start/stop automatically.
Use -h to see all options.
"""
parser = argparse.ArgumentParser(
description='Executes a data generator from the command-line. Calls JVM start/stop automatically.')
parser.add_argument("-j", metavar="classpath", dest="classpath", help="additional classpath, jars/directories")
parser.add_argument("-X", metavar="heap", dest="heap", help="max heap size for jvm, e.g., 512m")
parser.add_argument("datagenerator", help="data generator classname, e.g., weka.datagenerators.classifiers.classification.LED24")
parser.add_argument("option", nargs=argparse.REMAINDER, help="additional data generator options")
parsed = parser.parse_args()
jars = []
if not parsed.classpath is None:
jars = parsed.classpath.split(os.pathsep)
jvm.start(jars, max_heap_size=parsed.heap, packages=True)
logger.debug("Commandline: " + utils.join_options(sys.argv[1:]))
try:
generator = DataGenerator(classname=parsed.datagenerator)
if len(parsed.option) > 0:
generator.set_options(parsed.option)
DataGenerator.make_data(generator, parsed.option)
except Exception, e:
print(e)
finally:
jvm.stop()
if __name__ == "__main__":
try:
main()
except Exception, ex:
print(ex)
python-weka-wrapper-0.1.15/CHANGES.rst 0000644 0172670 0172670 00000010377 12444360525 020771 0 ustar fracpete fracpete 0000000 0000000 Changelog
=========
0.1.15 (2014-12-18)
-------------------
- fixed `Instance.set_value` method: https://github.com/fracpete/python-weka-wrapper/issues/24
- added sub-section `From source` to section on installing the library
- upgraded to Weka 3.7.12
0.1.14 (2014-12-16)
-------------------
- fixed `setup.py` to include the jars again when using eggs (via `include_package_data` etc)
- added detailed instructions for installing the library
0.1.13 (2014-11-01)
-------------------
- added `get_class` method to `weka.core.utils` which returns the Python class object associated
with the classname in dot-notation
- `from_commandline` method in `weka.core.utils` now takes an optional `classname` argument, which is
the classname (in dot-notation) of the wrapper class to return - instead of the generic `OptionHandler`
- added `Kernel` and `KernelClassifier` convenience classes to better handle kernel based classifiers
0.1.12 (2014-10-17)
-------------------
- added `create_string` class method to the `Attribute` class for creating a string attribute
- ROC/PRC curves can now consist of multiple plots (ie multiple class labels)
- switched command-line option handling from `getopt` to `argparse`
- fixed Instance.get_dataset(self) method
- added iterators for: rows/attributes in dataset, values in dataset row
- incremental loaders can be iterated now
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.15/MANIFEST.in 0000644 0172670 0172670 00000000263 12352664672 020726 0 ustar fracpete fracpete 0000000 0000000 recursive-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.15/setup.cfg 0000644 0172670 0172670 00000000264 12444361245 021002 0 ustar fracpete fracpete 0000000 0000000 [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.15/setup.py 0000644 0172670 0172670 00000007054 12444360427 020700 0 ustar fracpete fracpete 0000000 0000000 # This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# setup.py
# Copyright (C) 2014 Fracpete (pythonwekawrapper at gmail dot com)
import os
from setuptools import setup
from urllib2 import urlopen, URLError, HTTPError
def download_file(url, outfile):
"""
Downloads the file associated with the URL and saves it to the specified output file.
Taken from here: http://stackoverflow.com/a/4028894
:param url: the URL to download
:type url: str
:param outfile: the name of the output file
:type outfile: str
:returns: whether the download was successful
:rtype: bool
"""
try:
# Open the url
f = urlopen(url)
print("Downloading '" + url + "' to '" + outfile + "'")
# Open our local file for writing
with open(outfile, "wb") as local_file:
local_file.write(f.read())
# handle errors
except HTTPError, e:
print("HTTP Error: " + str(e.code) + " " + url)
return False
except URLError, e:
print("URL Error: " + str(e.reason) + " " + url)
return False
return True
def download_weka():
"""
Downloads the monolithic Weka jar from sourceforget.net if nececssary.
"""
url = "http://sourceforge.net/projects/weka/files/weka-3-7/3.7.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"
],
package_data={
"weka": ["lib/*.jar"],
},
include_package_data=True,
version="0.1.15",
author='Peter "fracpete" Reutemann',
author_email='pythonwekawrapper 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.15/DESCRIPTION.rst 0000644 0172670 0172670 00000000315 12341760024 021465 0 ustar fracpete fracpete 0000000 0000000 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.
python-weka-wrapper-0.1.15/PKG-INFO 0000644 0172670 0172670 00000014552 12444361245 020263 0 ustar fracpete fracpete 0000000 0000000 Metadata-Version: 1.1
Name: python-weka-wrapper
Version: 0.1.15
Summary: Python wrapper for the Weka Machine Learning Workbench
Home-page: https://github.com/fracpete/python-weka-wrapper
Author: Peter "fracpete" Reutemann
Author-email: pythonwekawrapper at gmail dot com
License: GNU General Public License version 3.0 (GPLv3)
Description: The **python-weka-wrapper** package makes it easy to run
Weka algorithms and filters from within Python. It offers access to Weka
API using thin wrappers around JNI calls using the **javabridge** package.
Changelog
=========
0.1.15 (2014-12-18)
-------------------
- fixed `Instance.set_value` method: https://github.com/fracpete/python-weka-wrapper/issues/24
- added sub-section `From source` to section on installing the library
- upgraded to Weka 3.7.12
0.1.14 (2014-12-16)
-------------------
- fixed `setup.py` to include the jars again when using eggs (via `include_package_data` etc)
- added detailed instructions for installing the library
0.1.13 (2014-11-01)
-------------------
- added `get_class` method to `weka.core.utils` which returns the Python class object associated
with the classname in dot-notation
- `from_commandline` method in `weka.core.utils` now takes an optional `classname` argument, which is
the classname (in dot-notation) of the wrapper class to return - instead of the generic `OptionHandler`
- added `Kernel` and `KernelClassifier` convenience classes to better handle kernel based classifiers
0.1.12 (2014-10-17)
-------------------
- added `create_string` class method to the `Attribute` class for creating a string attribute
- ROC/PRC curves can now consist of multiple plots (ie multiple class labels)
- switched command-line option handling from `getopt` to `argparse`
- fixed Instance.get_dataset(self) method
- added iterators for: rows/attributes in dataset, values in dataset row
- incremental loaders can be iterated now
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