Introduction
In this tutorial page I will present a nice graphical tool which can be used to draw 2D surfaces in plane.For now is implemented only MeshContour, known also as contour curves. In cartography, a contour line joins points of equal elevation (height) above a given level, such as mean sea level. A contour map is a map illustrated with contour lines, for example a topographic map, which thus shows valleys and hills, and the steepness of slopes.
While I was working to find a way to plot contour lines and contour areas, I tried various thing and through iterative approaches I found an algorithm which I hoped that I discovered. In the end, after additional research I found (it happen again and again) that there is already an algorithm which does the same thing in a striking similar way. This algorithm is called Marching Squares.
The idea behind of the algorithm is to build a rectangular grid area with values computed for each point of the grid. I named this object a MeshGrid. A MeshGrid is used to describe the behaviour of a function against some conditions which are used to define the contour lines.
The simplest MeshGrid can be computed from a grid of function values (which are scalar values in this case), and a threshold value used as the elevation of the contour plot. If the grid points are very dense, then a linear interpolation found for each square of the grid will produce a smooth looking curve.
The idea behind a contour map can be extended to any condition applied to the function values. We can think of a MeshGrid with multi-dimensional vectors and conditions could be functions applied on multi-dimensional values.
A simple example: simulation of a kernel density in 2 dimensions
Kernel density estimation is a procedure which enables one to estimate a probability density using only information from a sample of values. Usually a continuous probability density is a smooth curve, but if one has only a hand of sample values it is clear that it is difficult to estimate a continuous density with few discrete values. What kernel density estimation does is to 'spread' the probability mass from each sample value in its neighbourhood. In the end, if the local influences are summed up, a smooth density function appears.For a uni-variate sample variable DensityLine utility can be used together with KDE objects to build some graphs. The question is: how can this be done in 2 dimensions?
Well, all the kernel densities I used have the nice property that they are symmetric. Thus been said, we note that the 'spreading' of probability will be the same in any direction, for all the points at the same euclidean distance.
Suppose our sample has only 3 points. These 3 points are \( A=(3,3), B=(-1,-1), C=(-2,6)\). These points were chosen at random, they does not have any special meaning.
We will 'spread' probability mass around these points according with a normal distribution with standard deviation equals 2.
Frame xy = SolidFrame.newWrapOf(
Numeric.newWrapOf(3, -1, -2).withName("x"),
Numeric.newWrapOf(3, -1, 6).withName("y")
);
Normal d = new Normal(0, 2);
Numeric x = Numeric.newSeq(-3, 10, 0.05);
Numeric y = Numeric.newSeq(-3, 10, 0.05);
MeshGrid1D mg = new MeshGrid1D(x, y);
BiFunction
bi = (xx, yy) ->
IntStream.range(0, 3).mapToDouble(
row -> d.pdf(Math.sqrt(Math.pow(xx - xy.value(row, "x"), 2) + Math.pow(yy - xy.value(row, "y"), 2)))
).sum();
mg.fillWithFunction(bi);
Plot p = new Plot();
Var q = Numeric.newSeq(0, 1, 0.1);
double[] qq = mg.quantiles(q.stream().mapToDouble().toArray());
qq[qq.length - 1] = Double.POSITIVE_INFINITY;
for (int i = 0; i < q.rowCount() - 1; i++) {
p.add(new MeshContour(mg.compute(qq[i], qq[i + 1]), true, true)
.color(new Color(0.f, 0.f, 1f, (float) qq[i])).lwd(0.2f)
);
}
p.add(new Points(xy.var("x"), xy.var("y")));
draw(p, 600, 400);
A more complete example: iris classification
We will use again the classical UCI data set to build an example. Because SVM algorithm that is implemented work only for binary classification case, I will truncate the iris data set.Because petal variables separates very well all the case, I will use sepal variables, to make a little harder the problem. I will also filter our cases for the third class.
> summary(frame,
[sepal-length, sepal-width, class])
rowCount: 100
complete: 100/100
varCount: 3
varNames: [sepal-length, sepal-width, class]
sepal-length sepal-width class
Min. : 4.300 Min. : 2.000 Iris-setosa : 50
1st Qu. : 5.000 1st Qu. : 2.800 Iris-versicolor : 50
Median : 5.400 Median : 3.050
Mean : 5.471 Mean : 3.094
2nd Qu. : 5.900 2nd Qu. : 3.400
Max. : 7.000 Max. : 4.400
Frame iris = Datasets.loadIrisDataset();
iris = iris.mapVars("sepal-length,sepal-width,class");
iris = iris.stream().filter(s -> s.index(2)!=3).toMappedFrame();
iris = iris.solidCopy();
draw(new Plot().add(new Points(iris.var(0), iris.var(1)).color(iris.var(2))));
> ConfusionMatrix
| Predicted
Actual| Iris-setosa Iris-versicolor| Total
--------------- --------------- --------------- ---------------
Iris-setosa| 50 0| 50
Iris-versicolor| 0 50| 50
--------------- --------------- --------------- ---------------
Total| 50 50| 100
Complete cases 100 from 100
Acc: 1.000 (Accuracy )
F1: 1.000 (F1 score / F-measure)
MCC: 1.000 (Matthew correlation coefficient)
Pre: 1.000 (Precision)
Rec: 1.000 (Recall)
G: 1.000 (G-measure)
BinarySMO smo = new BinarySMO().withKernel(new PolyKernel(2));
smo.learn(iris, "class");
CResult cr = smo.predict(iris);
new ConfusionMatrix(iris.var("class"), cr.firstClasses()).summary();
The code to generate this is now a little bit tedious. Later on, after some good practice rules emerge from usage scenarios, this kind of procedures will be encapsulated into a more complex procedure with simple and fast syntax.
Last case: an interesting decision surface
I generated a data set consisting on some binary labeled points placed randomly on a chess board. The points are labels according with the color of the square which contains it. I used this in order to plot a nice example of drawing in interesting surface.> ConfusionMatrix
| Predicted
Actual| True False| Total
------ ------ ------ ------
True| 721 79| 800
False| 8 792| 800
------ ------ ------ ------
Total| 729 871| 1600
Complete cases 1600 from 1600
Acc: 0.946 (Accuracy )
F1: 0.943 (F1 score / F-measure)
MCC: 0.895 (Matthew correlation coefficient)
Pre: 0.989 (Precision)
Rec: 0.901 (Recall)
G: 0.944 (G-measure)
And the code which produced the last graph.
// build the data set
RandomSource.setSeed(1);
Var v1 = Numeric.newEmpty().withName("x");
Var v2 = Numeric.newEmpty().withName("y");
Var v3 = Nominal.newEmpty().withName("class");
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 100; k++) {
v1.addValue(RandomSource.nextDouble() + i);
v2.addValue(RandomSource.nextDouble() + j);
v3.addLabel((i + j) % 2 == 0 ? "True" : "False");
}
}
}
Frame df = SolidFrame.newWrapOf(v1, v2, v3);
// build classifier
Classifier c = new BinarySMO().withKernel(new WaveletKernel(0.55)).withC(0.1);
c.learn(df, "class");
new ConfusionMatrix(df.var("class"), c.predict(df).firstClasses()).summary();
// new build the mesh grid
x = Numeric.newSeq(new Minimum(df.var(0)).value() - 1, new Maximum(df.var(0)).value() + 1, 0.05).withName("x");
y = Numeric.newSeq(new Minimum(df.var(1)).value() - 1, new Maximum(df.var(1)).value() + 1, 0.05).withName("y");
mg = new MeshGrid1D(x, y);
Var x1 = Numeric.newEmpty().withName("x");
Var y1 = Numeric.newEmpty().withName("y");
for (int i = 0; i < x.rowCount(); i++) {
for (int j = 0; j < y.rowCount(); j++) {
x1.addValue(x.value(i));
y1.addValue(y.value(j));
}
}
// fit the mesh grid values
Frame grid = SolidFrame.newWrapOf(x1, y1);
cr = c.predict(grid, true, true);
pos = 0;
for (int i = 0; i < x.rowCount(); i++) {
for (int j = 0; j < y.rowCount(); j++) {
mg.setValue(i, j, cr.firstDensity().value(pos, 1) - cr.firstDensity().value(pos, 2));
pos++;
}
}
// and finally plot the results
p = new Plot();
double[] pp = new double[]{0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 1};
qq = mg.quantiles(pp);
for (int i = 0; i < qq.length - 1; i++) {
p.add(new MeshContour(mg.compute(qq[i], qq[i + 1]), false, true).color(new Color(0f, 0f, 1f, (float) pp[i + 1])));
}
p.add(new MeshContour(mg.compute(0, Double.POSITIVE_INFINITY), true, false).color(0).lwd(2f));
WS.draw(p.add(new Points(df.var(0), df.var(1)).color(df.var(2))), 800, 600);