UMAP clustering in Ruby
Tags: ruby, cpp, umap, datascience
Published: 2022-10-12 04:22:46

## Introduction

Uniform Manifold Approximation and Projection ([UMAP](https://github.com/lmcinnes/umap)) is a well-known dimensionality reduction method along with t-SNE.

Ruby users often use [Rumale](https://github.com/yoshoku/rumale) for machine learning. [t-SNE is included](https://yoshoku.github.io/rumale/doc/Rumale/Manifold/TSNE.html) in Rumale, but UMAP is not.

I have created a Ruby binding for [Umappp](https://github.com/LTLA/umappp), a C++ library, and will post it here before I forget.

**GitHub:** https://github.com/kojix2/ruby-umappp

## Create bindings when Ruby libraries do not exist!

Since the Ruby language is a relatively minor language in the field of data analysis, it is often the case that a library that implements what you want to do does not exist. In such cases, you can look for libraries in languages such as C or Rust to build Ruby bindings. GitHub allows you to search for code by language. This can be used to find libraries for C. Since GitHub allows tagging of projects, searching for the target tag can also be helpful. However, UMAP seems to be difficult to implement, and I could not find a C library that implements UMAP. Instead, I found a library that implements UMAP in C++. That is [Umappp](https://github.com/LTLA/umappp).

## Umappp - UMAP C++ implementation 

Umappp is a C++ library implemented by Aaron Lun. it is developed based on the R library [uwot](https://github.com/jlmelville/uwot). it is implemented in C++ and uses OpenMP, so high performance is expected.

## Calling C++ functions from the Ruby language

Extension libraries using C++ are common in the R language, but C++ extension libraries are not so widely used in the Ruby language. Recently, Rust is very popular, and I sometimes see people building Ruby extensions in Rust, but I have not seen many new C++ extension libraries.

However, creating C++ bindings in Ruby is easier than you might think. I have no experience with C++, but I was able to call C++ from Ruby.

There are two ways to write Ruby extensions in C++. One is [Rice](https://github.com/jasonroelofs/rice) and the other is [extpp](https://github.com/red-data-tools/extpp). In this case, I used Rice because I wanted to use [numo.hpp](https://github.com/ankane/numo.hpp) to link [Numo::NArray](https://github.com/ruby-numo/numo-narray) and C++.

In order to be able to compile C++ at runtime, Umappp and all C++ files on which Umappp depends are put in the Vendor directory and distributed as a gem.`extconf.rb` is a script that creates a Makefile. I didn't know how to write this, so I wrote it based on other projects. 

## Rice -  Ruby Interface for C++ Extensions 

Rice is a library developed by Paul Brannan, Charlie Savage, Jason Roelofs and others for writing C++ extensions in Ruby. Using Rice, you can define Ruby modules and methods from C++ code as shown below.

```cpp
#include <rice/rice.hpp>
#include <rice/stl.hpp>

using namespace Rice;

Hash umappp_default_parameters(Object self)
{
  Hash d;
// ...
  return d;
}

// ...

extern "C" void Init_umappp()
{
  Module rb_mUmappp =
      define_module("Umappp")
          .define_singleton_method("umappp_run", &umappp_run)
          .define_singleton_method("umappp_default_parameters", &umappp_default_parameters);
}
```

## Run UMAP in Ruby

Run UMAP on the famous Iris dataset and the MNIST database.

* For visualization, I used GR.rb.
* For dataset fetching, I used red-datasets and its derived library red-datasets-numo-narray.

### Iris dataset

Ruby code:

```ruby
require "umappp"
require "datasets-numo-narray"
require "gr/plot"

iris = Datasets::LIBSVM.new("iris").to_narray
d = iris[true, 1..-1]
l = iris[true, 0]

r = Umappp.run(d)
x = r[true, 0]
y = r[true, 1]
s = [2000] * l.size

GR.scatter(
  x, y, s, l,
  title: "iris",
  colormap: 16,
  colorbar: true
)
gets
```

![iris.png](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dsxrt54gtw7g4wtadxxy.png)

The clusters were clearly separated. Here, label 0 (setosa) is light blue, label 1 (versicolor) is wisteria, and label 2 (virginica) is magenta. The setosa group is clearly separated from the other groups, while versicolor and virginica partially overlap. 

### Mnist database

Ruby code:

```ruby
require "umappp"
require "datasets"
require "gr/plot"
require "etc"

mnist = Datasets::MNIST.new

pixels = []
labels = []
mnist.each_with_index do |r, _i|
  pixels << r.pixels
  labels << r.label
end

puts "start umap"
nproc = Etc.nprocessors
n = nproc > 4 ? nproc - 1 : nproc
d = Umappp.run(pixels, num_threads: n, a: 1.8956, b: 0.8006)
puts "end umap"

x = d[true, 0]
y = d[true, 1]
s = [500] * x.size

GR.scatter(x, y, s, labels, colormap: 0)

gets
```

If you monitor CPU utilization in an environment with OpenMP installed, you will see that multiple cores are in use. 

![mnist.png](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8neseedghqnbj7i2q6jb.png)

The cluster has been divided very nicely. Each cluster is labeled with a number. This roughly matches the [official UMAP results](https://speakerdeck.com/lmcinnes/umap-uniform-manifold-approximation-and-projection-for-dimension-reduction?slide=57). UMAP is running successfully. 5-3-8 and 4-9-7 form a group. The similarity between the handwritten letters 4 and 9 is intuitively obvious. I have a habit of writing 1 to resemble 7, but not many people do that.

![mnist](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nsx1fz6w6x0b0ui3clt4.png)

Let's try 3D. GR.rb has a GIF animation output function.

```ruby
puts "start umap #{n} threads"
d = Umappp.run(pixels, ndim: 3, num_threads: n, a: 1.8956, b: 0.8006)
puts "end umap"

x = d[true, 0]
y = d[true, 1]
z = d[true, 2]

Dir.chdir(__dir__) do
  # Save results
  File.binwrite("data/mnist2.dat", Marshal.dump([d, labels]))
  puts "Saved to data/mnist2.dat"
  # Save gif animation
  GR.beginprint("data/mnist2.gif") do
    30.times do |i|
      puts "frame #{i + 1}"
      GR.scatter3(x, y, z, labels, colormap: 0, backgroundcolor: 1, rotation: i * 3)
    end
  end
  puts "Saved to data/mnist2.gif"
end
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/syz0z42ues2r2migo9fv.gif)

Unfortunately, GR.rb calls `polymarker3d` in sequence, so some points that should be behind are in front and some points that should be in front are behind. However, it is interesting that the 2D position is consistent with the 3D position.

In GR.rb, it is not clear which set of colors corresponds to which number, since the scatter plot and color bar cannot be displayed at the same time. There is room for improvement on this point.

The author is not very good at mathematics and does not understand the details of how UMAP works at all. So I can't say anything nice about UMAP, but if it works this fast, I thought it might be useful to use UMAP to look up data I'm interested in. I also felt that the results were more reproducible than I expected.

## Conclusion

In this post, I have shown how to call C++ from Ruby to execute UMAP. As far as I know, this is the first library that can run UMAP in Ruby, including bindings.

Thus, another Ruby gem has been created.

Have a nice day!