Speed up jekyll related posts functionality (--lsi, classifier-reborn, gsl, nmatrix, narray, Numo:NArray, Numo:GSL)

[0xdevalias]

(See also: #1)

Jekyll can "create an index for related posts" using the --lsi build command option, which uses the classifier-reborn gem to create a site variable of related posts:

• https://jekyllrb.com/docs/configuration/options/#build-command-options
• https://jekyllrb.com/docs/variables/#site-variables

  • site.related_posts: If the page being processed is a Post, this contains a list of up to ten related Posts. By default, these are the ten most recent posts. For high quality but slow to compute results, run the jekyll command with the --lsi (latent semantic indexing) option. Also note GitHub Pages does not support the lsi option when generating sites.

• https://jekyll.github.io/classifier-reborn/
• https://jekyll.github.io/classifier-reborn/#dependencies

  • To speed up LSI classification by at least 10x consider installing following libraries.

    • http://www.gnu.org/software/gsl
    • https://rubygems.org/gems/gsl

  • Note that LSI will work without these libraries, but as soon as they are installed, classifier will make use of them.

More info on Jekyll's usage of LSI:

• https://www.aravindiyer.com/tech/yet-another-solution-related-posts-jekyll/
• http://sangsoonam.github.io/2019/01/15/random-related-posts-in-jekyll.html

The gsl gem can make use of nmatrix and narray:

• https://github.com/SciRuby/rb-gsl#nmatrix-and-narray-usage
• https://github.com/SciRuby/nmatrix
• https://github.com/masa16/narray

narray is in maintenance mode, and directs to numo-narray:

• https://github.com/masa16/narray#new-version-is-under-development---rubynumonarray
• https://github.com/ruby-numo/numo-narray

numo-gsl provides a GSL interface for Ruby with Numo::NArray:

• https://github.com/ruby-numo/numo-gsl

I'm unsure if the numo gems can be used with classifier-reborn, and which of nmatrix/narray provide better speed; but I created an issue asking:

• Can classifier-reborn work with Numo::NArray / Numo::GSL ? Is that a better choice than nmatrix? jekyll/classifier-reborn#192

As noted in jekyll/classifier-reborn#193, i'm not sure if classifier-reborn is actively updated/maintained.

---

nmatrix was last updated in 2018, and at least one issue claims that Numo::NArray outperforms NMatrix

Several years have passed since the new version of NArray came out.

It appeared that NMatrix was not being maintained well.
And I think Numo::NArray now outperforms NMatrix in almost every way. (benchmark needed)

Newcomers try NMatrix first. After a while, they notice that NArray is far better in performance.
And they begin to make libraries dependent on NArray.

---

rb-gsl was last updated in 2017, and claims compatibility only with GSL versions up to v2.1:

Ruby/GSL is compatible with GSL versions upto 2.1.

I've asked if it is still maintained, but my guess is probably not:

• Is this project still maintained? SciRuby/rb-gsl#63

---

My comment in reply to the following StackOverflow question:

• https://stackoverflow.com/questions/51439500/jekyll-build-lsi-make-blog-very-very-slow/63006543#63006543

The `--lsi` option comes from the [`classifier-reborn`][1] gem, which includes the following note about increasing speed under the [dependencies][2] heading:

> To speed up LSI classification by at least 10x consider installing
> following libraries.
> 
> [GSL - GNU Scientific Library][3]
>
> [Ruby/GSL Gem][4]
> 
> Note that LSI will work without these libraries, but as soon as they
> are installed, classifier will make use of them. No configuration
> changes are needed, we like to keep things ridiculously easy for you.

The [`gsl` gem's installation docs][5] mentions:

> the GSL libraries must already be installed before Ruby/GSL can be installed:
>
> - Debian/Ubuntu: +libgsl0-dev+
> - Fedora/SuSE: +gsl-devel+
> - Gentoo: +sci-libs/gsl+
> - OS X: `brew install gsl`

The [`gsl` gem can also make use of `nmatrix` or `narray`][6], which I believe may further increase the speed/efficiency:

> In order to use rb-gsl with NMatrix you must first set the NMATRIX
> environment variable and then install rb-gsl:
> - `gem install nmatrix`
> - `export NMATRIX=1`
> - `gem install rb-gsl`
> 
> This will compile rb-gsl with NMatrix specific functions.
> 
> For using rb-gsl with NArray:
> - `gem install narray`
> - `export NARRAY=1`
> - `gem install rb-gsl`
> 
> Note that setting both `NMATRIX` and `NARRAY` variables will lead to
> undefined behaviour. Only one can be used at a time.

I'm not sure whether `nmatrix` or `narray` is the better/faster choice, though I did open `https://github.com/jekyll/classifier-reborn/issues/192` on the `classifier-reborn` repo.

I did notice that the old [narray GitHub repo][7] mentions that the package is no longer maintained, and instead links to a new version: [Ruby/Numo::NArray][8]

> Numo::NArray is an Numerical N-dimensional Array class for fast processing and easy manipulation of multi-dimensional numerical data, similar to numpy.ndaray. This project is the successor to Ruby/NArray.

Numo::NArray also links to [`numo-gsl`][9], which appears to be related gsl bindings:

> GSL interface for Ruby/Numo::NArray

At this stage i'm not sure if `classifier-reborn` is able to make use of any of these numo dependencies, but if it can, my guess is that they are going to be faster/more actively maintained.

  [1]: https://jekyll.github.io/classifier-reborn/
  [2]: https://jekyll.github.io/classifier-reborn/#dependencies
  [3]: http://www.gnu.org/software/gsl
  [4]: https://rubygems.org/gems/gsl
  [5]: https://github.com/SciRuby/rb-gsl#installation
  [6]: https://github.com/SciRuby/rb-gsl#nmatrix-and-narray-usage
  [7]: https://github.com/masa16/narray#new-version-is-under-development---rubynumonarray
  [8]: https://github.com/ruby-numo/narray
  [9]: https://github.com/ruby-numo/numo-gsl

See Also

• Remove gsl/nmatrix dependencies from Gemfile and build workflow #87

[0xdevalias]

Found some benchmarks comparing various underlying options (though they seem rather outdated)

• https://gist.github.com/colstrom/1bc7ea694286c0a96119295a8866a857

  • Ruby Vector Benchmarks (matrix vs nmatrix vs numo/narray)

[0xdevalias]

Looking at site build times in #86 (comment) with/without --lsi, gsl, nmatrix, etc; it seemed to have negligible impact regardless of which we used.

In light of that.. this thread about optimisations may not even be relevant anymore..

[mkasberg]

👋 Hi,

I stumbled onto this thread from jekyll/classifier-reborn#193.

A few notes that you might find helpful:

• You're not noticing any difference in build times with the --lsi option because your site (as it is today in this repo) doesn't use related posts (so the --lsi option does nothing). To use LSI, you need to call site.related_posts somewhere in a Liquid template. For example, you might add something like the following to _layouts/post.html:

  {% for post in site.related_posts limit:3 %}
    <p>{{ post.title }}</p>
  {% endfor %}

• When you call site.related_posts, if you don't pass the --lsi option, it's just recent posts.
• If you are using site.related_posts and you pass the --lsi option, You'll see Populating LSI... in your jekyll build --lsi output. The build will be slow unless you have the gsl gem and native gsl library installed. I haven't experimented with nmatrix or narray at all, but simply using the gsl gem results in a ~500x speed increase for my use.

Hope that helps. I appreciated some of your comments on some of the libraries so I thought I'd share some notes with you!

[0xdevalias]

@mkasberg Thanks for the notes and insights :) Much appreciated.

I’d have to look deeper at things (has been a long time since I did), but if the related_posts part isn’t there anymore then I guess I must have removed it from my templates at some stage. I know I had it at one point. Maybe the speed thing was why I removed it.

If/when I get back to looking at this I’ll make sure to check that out first!

[0xdevalias]

The referenced issue links from the Gemfile:

• Speed up jekyll related posts functionality (--lsi, classifier-reborn, gsl, nmatrix, narray, Numo:NArray, Numo:GSL) #83
• Can classifier-reborn work with Numo::NArray / Numo::GSL ? Is that a better choice than nmatrix? jekyll/classifier-reborn#192
  • Support Numo Gem for performing SVD jekyll/classifier-reborn#198
    • https://github.com/jekyll/classifier-reborn/releases/tag/v2.3.0

      • Support Numo Gem for performing SVD

      • https://jekyll.github.io/classifier-reborn/#dependencies

        • It is recommended to install either Numo or GSL to speed up LSI classification by at least 10x.

        • Numo is a set of Numerical Module gems for Ruby that provide a Ruby interface to LAPACK. If classifier detects that the required Numo gems are installed, it will make use of them to perform LSI faster.

          • Install LAPACKE
            • Ubuntu: apt-get install liblapacke-dev
            • macOS: brew install lapack
          • Install OpenBLAS
            • Ubuntu: apt-get install libopenblas-dev
            • macOS: brew install openblas
          • Install the Numo::NArray and Numo::Linalg gems. If you're using Bundler, add numo-narray and numo-linalg to your Gemfile. (If using Bundler on macOS, you should set the build config like bundle config set --global build.numo-linalg --with-openblas-dir=$(brew --prefix openblas) --with-lapack-lib="$(brew --prefix lapack)/lib".)
            • Ubuntu: gem install numo-narray numo-linalg
            • macOS: gem install numo-narray, gem install numo-linalg -- --with-openblas-dir=$(brew --prefix openblas) --with-lapack-lib="$(brew --prefix lapack)/lib"

          • fix missing code tag backtick mkasberg/classifier-reborn#6
• Is this project still maintained? SciRuby/rb-gsl#63

It seems rb-gsl only compatible up to gsl 2.1 as well:

• https://github.com/SciRuby/rb-gsl#description

  • Ruby/GSL is compatible with GSL versions upto 2.1.

  • https://github.com/SciRuby/rb-gsl#usage-with-gsl-21
• Please remove wrapping of functions deprecated in GSL 2.2.1 SciRuby/rb-gsl#41

Originally posted by @0xdevalias in #20 (comment)

[0xdevalias]

The following posts by @mkasberg are also worth reading/considering before going too deep with this:

• https://www.mikekasberg.com/blog/2022/07/12/how-i-updated-jekyll-classifier-reborn-for-ruby-3.html

  • How I Updated jekyll/classifier-reborn for Ruby 3 (12 Jul 2022)

  • This blog basically relates to the work linked above
• https://www.mikekasberg.com/blog/2024/04/23/better-related-posts-in-jekyll-using-ai.html

  • Better Related Posts in Jekyll Using AI (23 Apr 2024)

  • https://github.com/mkasberg/jekyll_ai_related_posts

    • Generate Jekyll related posts with AI

    • When the plugin is installed and configured, it will populate an ai_related_posts key in the post data for all posts.

    • The first time the plugin runs, it will fetch embeddings for all your posts. Based on some light testing, this took me 0.5 sec per post, or about 50 sec for a blog with 100 posts. All subsequent runs will be faster since embeddings will be cached.

    • On an example blog with ~100 posts, this plugin produces more accurate results than classifier-reborn (LSI) in about the same amount of time.

    • The API costs to use this plugin with OpenAI's API are minimal. I ran this plugin for all 84 posts on mikekasberg.com for $0.00 in API fees (1,277 tokens on the text-embedding-3-small model). (Your results may vary, but should remain inexpensive.)

Having ChatGPT explain the differences between using LSI and embeddings for this purpose:

Latent Semantic Indexing (LSI)

• Method: Uses Singular Value Decomposition (SVD) on term-document matrices.
• Representation: Lower-dimensional space capturing latent semantic structures.
• Applications: Information retrieval, document clustering, text summarization.
• Advantages: Handles synonymy, less computationally intensive.
• Limitations: Limited in capturing complex linguistic phenomena, performance depends on the corpus.

Embeddings (e.g., OpenAI embeddings)

• Method: Uses deep learning models like transformers.
• Representation: Dense vectors capturing semantic meaning, context, and relationships.
• Applications: Sentiment analysis, text classification, named entity recognition, question answering.
• Advantages: Captures complex linguistic phenomena, state-of-the-art performance, versatile.
• Limitations: Computationally intensive, requires significant resources, may need fine-tuning.

Summary

• LSI is simpler and effective for basic tasks but less nuanced.
• Embeddings provide richer, context-aware representations and superior performance on a wide range of tasks but require more computational power.

Originally posted by @0xdevalias in #87 (comment)