weka | A Python wrapper for Weka | Machine Learning library

I have turned your code snippet into one with imports and fixed the MultiSearch setup for Bagging (mparam.prop = "numIterations" instead of mparam.prop = "numOfBoostingIterations"), allowing it to be executed.

Since I do not have access to your data, I just used the UCI dataset vote.arff.

Your code was a bit odd, as it did a 70/30 train/test split, trained the classifier and then performed cross-validation on the test data. For cross-validation you do not train the classifier, as this happens within the internal cross-validation loop (each trained classifier inside that loop gets discarded, as cross-validation is only used for gathering statistics).

The code below has therefore three parts:

1. your original evaluation code, but commented out
2. performing proper cross-validation
3. performing train/test evaluation

I do not use Jupyter notebooks and tested the code successfully in a regular virtual environment on my Linux Mint:

• Python: 3.8.10
• Output of pip freeze:

Yes, of course you can make predictions with a model. Since it is not clear, whether you want to do that from the command-line, in the GUI or from code, I recommend you have a look at the following Weka wiki article:

https://waikato.github.io/weka-wiki/making_predictions/

If you want to use the API, check the articles listed here:

https://waikato.github.io/weka-wiki/using_the_api/

Also, every Weka installation comes with code examples, aptly named wekaexamples.zip.

You need to instantiate ASSearch and ASEvaluation objects. If you have command-lines, you can use the from_commandline helper method like this:

The StringToWordVector filter uses the weka.core.DictionaryBuilder class under the hood for the TF/IDF computation.

As long as you create a weka.core.Instance object with the text that you want to have converted, you can do that using the builder's vectorizeInstance(Instance) method.

Edit 1:

Below is an example based on your code (but with Weka classes), which shows how to either use the filter or the DictionaryBuilder for the TF/IDF transformation. Both get serialized, deserialized and re-used as well to demonstrate that these classes are serializable:

python-weka-wrapper3, as the name suggests, is a light-weight wrapper around Weka classes. However, it mostly only wraps abstract superclasses, not all of the thousands of classes that make up Weka.

The weka.classifiers.Classifier class is the wrapper to use for classifiers and you need to specify the Java classname of the actual classifier that you want to wrap (in your case weka.classifiers.trees.ADTree). And, yes, just like Python, Java is also case sensitive.

Furthermore, if you require classes from packages, then you need to start the JVM with package support (default is no package support).

Below is an example that outputs the command-line of ADTree with its default parameters. If necessary, it installs the package first.

I'm not quite sure why you have a problem with the output of the filter. Maybe the following will make it apparent to you how the filter functions.

Here is your data in one table, slightly rearranged:

The exceptions that you listed do not affect the script execution, as they get handled internally by pww3 (error output could not be suppressed, unfortunately, despite catching the exceptions; this gets output by the underlying javabridge library).

A bit of background: Since pww3 can run with and without package support, it first tries to load classes using the Java classloader. If that fails (that's the error message that you see), it will try loading them using Weka's mechanism for loading classes.

The just released version 0.2.7 of pww3 approaches this a bit more intelligent and avoids the output of these exceptions.

Final note: you need to drop the classifier. prefix in your property names when using MultiSearch.

Though they both are decision trees, they employ different algorithms for constructing the tree, which will (most likely) give you a different outcome:

• J48 prunes the tree by default after it built its tree (Wikipedia).
• RandomTree (when using default parameters) inspects a maximum of log2(num_attributes) attributes for generating splits.

Every classifier, clusterer, filter etc in Weka can only handle certain types of data, i.e., its capabilities (which you can check in GUI). These capabilities are then compared against the data. In case of a mismatch, the GUI won't allow you to apply the algorithm.

Long story short: the dport attribute is of type string which NaiveBayes can't handle. You can convert that attribute into a nominal one using the StringToNominal filter.