js-rouge

A JavaScript implementation of the Recall-Oriented Understudy for Gisting Evaluation (ROUGE) evaluation metric for summaries. This package implements the following metrics:

• n-gram (ROUGE-N)
• Longest Common Subsequence (ROUGE-L)
• Skip Bigram (ROUGE-S)

Note: This is a fork of the original ROUGE.js by kenlimmj. This fork adds TypeScript types, security fixes, and other improvements.

Rationale

ROUGE is somewhat a standard metric for evaluating the performance of auto-summarization algorithms. However, with the exception of MEAD (which is written in Perl. Yes. Perl.), requesting a copy of ROUGE to work with requires one to navigate a barely functional webpage, fill up forms, and sign a legal release somewhere along the way while at it. These definitely exist for good reason, but it gets irritating when all one wishes to do is benchmark an algorithm.

Nevertheless, the paper describing ROUGE is available for public consumption. The appropriate course of action is then to convert the equations in the paper to a more user-friendly format, which takes the form of the present repository. So there. No more forms. See how life could have been made a lot easier for everyone if we were all willing to stop writing legalese or making people click submit buttons?

Quick Start

This package is available on NPM:

npm install js-rouge

To use it:

import { n, l, s } from "js-rouge"; // ES Modules

// OR

const { n, l, s } = require("js-rouge"); // CommonJS

Usage

js-rouge provides three main functions:

• ROUGE-N: n(candidate, reference, opts) - N-gram overlap
• ROUGE-L: l(candidate, reference, opts) - Longest Common Subsequence
• ROUGE-S: s(candidate, reference, opts) - Skip-bigram co-occurrence

All functions return an F-score between 0 and 1.

ROUGE-N Example

import { n as rougeN } from "js-rouge";

const candidate = "the cat sat on the mat";
const reference = "the cat sat on the mat";

// ROUGE-1 (unigram)
rougeN(candidate, reference, { n: 1 }); // => 1.0

// ROUGE-2 (bigram)
rougeN(candidate, reference, { n: 2 }); // => 1.0

// With partial match
rougeN("the cat sat", "the cat sat on the mat", { n: 1 }); // => 0.75

ROUGE-L Example

import { l as rougeL } from "js-rouge";

const reference = "police killed the gunman";
const candidate = "police kill the gunman";

rougeL(candidate, reference); // => 0.75

ROUGE-S Example

import { s as rougeS } from "js-rouge";

const reference = "police killed the gunman";
const candidate = "police kill the gunman";

// Default: considers all word pairs
rougeS(candidate, reference); // => 0.5

// With skip distance limit
rougeS(candidate, reference, { maxSkip: 2 }); // considers only nearby word pairs

Case Sensitivity

All functions are case-sensitive by default. Use caseSensitive: false for case-insensitive comparison:

import { n as rougeN } from "js-rouge";

rougeN("Hello World", "hello world"); // => 0 (no match)
rougeN("Hello World", "hello world", { caseSensitive: false }); // => 1.0

Options

ROUGE-N Options

ROUGE-L Options

ROUGE-S Options

Limitations

• English-centric tokenizer: The default Penn Treebank tokenizer is designed for English text. For other languages, provide a custom tokenizer function that appropriately segments text in your target language.

Jackknife Resampling

The package also exports utility functions, including jackknife resampling as described in the original paper:

import { n as rougeN, jackKnife } from "js-rouge";

const reference = "police killed the gunman";
const candidates = [
  "police kill the gunman",
  "the gunman kill police",
  "the gunman police killed",
];

// Standard evaluation taking the arithmetic mean
jackKnife(candidates, reference, rougeN);

// Modified evaluation taking the distribution maximum
const distMax = (arr) => Math.max(...arr);
jackKnife(candidates, reference, rougeN, distMax);

TypeScript

This package is written in TypeScript and includes type definitions. All functions and utilities are fully typed.

import { n, l, s, jackKnife } from "js-rouge";

const score: number = n("candidate text", "reference text", { n: 2 });

Exported Types

Option interfaces are exported for typing your own functions and configurations:

import { n, RougeNOptions, RougeSOptions, RougeLOptions } from "js-rouge";

// Type your options objects
const opts: RougeNOptions = { n: 2, caseSensitive: false };
const score = n("candidate", "reference", opts);

// Type function parameters
function evaluateSummary(
  candidate: string,
  reference: string,
  opts: RougeNOptions,
): number {
  return n(candidate, reference, opts);
}

Versioning

Development will be maintained under the Semantic Versioning guidelines as much as possible in order to ensure transparency and backwards compatibility.

Releases will be numbered with the following format:

<major>.<minor>.<patch>

And constructed with the following guidelines:

• Breaking backward compatibility bumps the major (and resets the minor and patch)
• New additions without breaking backward compatibility bump the minor (and resets the patch)
• Bug fixes and miscellaneous changes bump the patch

For more information on SemVer, visit http://semver.org/.

Bug Tracking and Feature Requests

Have a bug or a feature request? Please open a new issue.

Contributing

Please submit all pull requests against the main branch. All code should pass ESLint validation and tests.

The amount of data available for writing tests is unfortunately woefully inadequate. We've tried to be as thorough as possible, but that eliminates neither the possibility of nor existence of errors. The gold standard is the DUC data-set, but that too is form-walled and legal-release-walled, which is infuriating. If you have data in the form of a candidate summary, reference(s), and a verified ROUGE score you do not mind sharing, we would love to add that to the test harness.

License

MIT