The Weka API: Matrix class

Weka includes a matrix library in weka.core.matrix.Matrix. This library is adapted from the JAMA package, originally developed by NIST and the University of Maryland. The aim of the library is to support functions for numerical linear algebra.

Creating a Matrix Instance

To create a Matrix instance from jRuby, I use the following construction method. It takes a two-dimensional Ruby array as argument, and returns an instance of the Matrix class.

def make_matrix array_2d
  matrix = Matrix.new(array_2d.length, array_2d[0].length)
  array_2d.length.times do |i|
      array_2d[0].length.times do |j|
          matrix.set(i, j, array_2d[i][j])
      end
   end
   return matrix
end

For example: puts make_matrix([[1,2,3], [4,5,6], [7,8,10]])
displays

1 2 3
4 5 6
7 8 10

Solving a Linear System

The example within the Weka documentation solves the following problem:

Solving using jRuby is equally trivial:

A = make_matrix [[1,2,3], [4,5,6], [7,8,10]]
b = make_matrix [[0.1],[0.2],[0.3]]
x = A.solve b

Warning: although the matrices can be converted to strings using to_s, the result is limited in decimal places, which can be misleading. Better to display the solution using explict 'get' statements, such as:

puts "Solution: "
puts x.get(0,0), x.get(1,0), x.get(2,0)

Solution:
-0.0333333333333334
0.0666666666666667
-3.46944695195361e-17

Arithmetic on Matrices

The Matrix library supports several standard operations on matrices. It is easy to add, subtract, or multiply two matrices which are of the right 'shape'. For example, to find the 'residual' from the above solution: ||Ax - b||

r = A.times(x).minus(b)
puts r.normInf

(Here, 'normInf' is the infinity norm: the maximum value in the rows of the matrix 'r'. The library supports other norms. The popular "square root of sum of squares" is represented by 'normF', the Frobenius norm.)

The Weka API: Overview

The Weka data mining library makes available an extensive range of functionality, some of it hidden unless you delve into the API documentation. So, over the next few weeks, I intend to work through some of this documentation, and get a clearer picture of what is available and how to use it from jRuby. I am currently using the developer version 3.7, which you can find on the Weka website.

I start by opening up the Weka documentation in a browser, and this reveals a number of packages, some with many subpackages. In alphabetical order, the main packages are:

weka.associations:

The items in this package are for learning association rules: such rules are relations between variables in the data. There are two interfaces and several classes. The classes include standard algorithms such as APriori.

weka.classifiers:

The items in this package are for constructing classification models: these are models which predict the value of a specified attribute from the remaining attributes. This package is quite complex, and has several layers to it. There are four interfaces and a number of classes. The more familiar classifiers, such as J48 or LibSVM, are subclasses of the abstract class Classifier, and are grouped within subpackages. Some of the other classes, such as EnsembleLibrary, are for handling groups of classifiers.

The subpackages bring together the main groups of classificaion algorithms, such as bayes, functions, trees etc. These subpackages contain classes with concrete implementations of classification models, such as NaiveBayes and J48.

weka.clusterers:

This package contains concrete classes for a number of standard clustering algorithms, including Cobweb and SimpleKMeans: a clustering algorithm groups instances of data based on their similarity. Also, some interfaces and abstract classes are present for organising the clustering algorithms into groups, such as those which can estimate density for an instance.

weka.core:

This package contains many 'day-to-day' classes such as Instance and Instances. There are also classes such as EuclideanDistance and EditDistance which compute distances between instances or strings, respectively. MathematicalExpression is a class for evaluating strings containing expressions adhering to a simple grammar. There are over 70 classes in total, so plenty to explore.

weka.datagenerators and weka.estimators:

These packages provide ways to generate and estimate data based on distributions of values.

weka.experiment:

This package contains some interesting 'organisational' interfaces and classes. For example, the 'ResultsProducer' is an interface for objects which work with different randomisations of a dataset. The CrossValidationResultProducer is an implementation of this interface which organises a run of n-fold cross validation.

A collection of classes starting 'Result' provide ways of outputting data in standard formats, such as for GnuPlot, HTML etc.

This is the kind of material I tend to start coding myself, and perhaps I could save some time by using this package instead!

weka.filters:

Filters are techniques for modifying the dataset, either by modifying the number or balance of instances, or by altering the values of attributes themselves. Some useful examples include PrincipalComponents, which performs a transformation of the data, and RandomProjection, which reduces the dimensionality of data.

weka.gui:

Many of these classes are for the Weka graphical environment, but some components can be usefully reused in our own GUIs. These include visualisations of trees and other datatypes, which are under subpackages such as treeviewer and visualize.