Current progress on evaluation module. See readme & documentation for usage.

evaluation/README.md

@@ -0,0 +1,35 @@
+# Evaluation
+This module contains utilities and scripts for empirical, numerical evaluation of model outputs. Much of the code written in this module is guided by methodologies described in [this paper](https://staff.aist.go.jp/m.goto/PAPER/TIEICE202309watanabe.pdf) (Watanabe, 2023). 
+
+### Data formatting
+Using the [evaluate_model.py](evaluate_model.py) script, evaluation can be run on an existing `json` database of outputs. Database must contain a list of song containers in the following format:
+```json
+[
+    { // container for song 1
+        "id": (int) ...,
+        "prompt": (str) ...,                  //optional
+        "model_response": (str) ...,
+        "target_response": (str) ...          //optional
+    },
+    { // container for song 2
+        "id": (int) ..., // unique from song 1
+        "prompt": (str) ...,                  //optional
+        "model_response": (str) ...,
+        "target_response": (str) ...          //optional
+    },
+    .
+    .
+    .
+]
+```
+
+### Quick start
+Run the following script to quick start an evaluation:
+```bash
+py evaluation/evaluate_model.py <path_to_your_database> 
+```
+
+To run different measures, consider passing in a list of measures into the `--measures` argument:
+```bash
+py evaluation/evaluate_model.py <path_to_your_database> --measures diversity meter syllable
+```

evaluation/encode_lines.py

@@ -0,0 +1,101 @@
+import syllable_analysis as sylco
+import meter_analysis as metco
+import re, unidecode
+
+
+def prep_encoding(text):
+    """
+    Cleans text by removing whitespace, replacing nonstandard characters with
+    their standard counterparts, etc
+
+    Parameters
+    ----------
+    text : str
+        any text
+
+    Returns
+    -------
+    str
+        cleaned text
+    """
+    text = unidecode.unidecode(text).strip()
+
+    if not re.search(r"\S", text):
+        text = ""
+    return text
+
+
+def encode_line_meter_count(line, to_stdout=False):
+    """
+    Encodes a song line (line of text) into a line of digit words representing
+    the stress of each word in the line.
+
+    Ex:
+        what so proudly we hailed at the twilight's last gleaming
+            -> 1 1 10 1 1 1 0 12 1 10
+
+    Parameters
+    ----------
+    line : str
+        string of words (line)
+    to_stdout : bool, optional
+        whether to print to stdout, by default False
+
+    Returns
+    -------
+    str
+        string of stress encodings (digits)
+    """
+    line = prep_encoding(line)
+
+    if line == "":
+        if to_stdout:
+            print(line)
+        return ""
+
+    line_stress_list = metco.get_line_meter(line)
+    out = " ".join(line_stress_list)
+
+    if to_stdout:
+        print(out)
+    return out
+
+
+def encode_line_syllable_count(line, to_stdout=False):
+    """
+    Encodes a song line (line of text) into a line of digits representing
+    the number of syllables per line.
+    Ex:
+        the quick brown fox jumps over the lazy dog
+            -> 1 1 1 1 1 1 1 2 1
+
+    Parameters
+    ----------
+    line : str
+        string of words (line)
+    to_stdout : bool, optional
+        whether to print to stdout, by default False
+
+    Returns
+    -------
+    string
+        string of digits, one digit per word
+    """
+    line = prep_encoding(line)
+
+    if line == "":
+        if to_stdout:
+            print(line)
+        return line
+
+    words = re.findall(r"\b\w+\b", line)
+    syllable_counts = [sylco.count_syllables(word) for word in words]
+
+    out = " ".join(map(str, syllable_counts))
+
+    if to_stdout:
+        if len(syllable_counts) > 0:
+            out += " " * (30 - len(out))
+            out += f": {sum(syllable_counts)}"
+        print(out)
+    return out

evaluation/evaluate_model.py

@@ -0,0 +1,106 @@
+from score_acculumator import ScoreAccumulator
+import argparse, json, os
+
+
+def main(filepath, measures, writeback=False, outpath=""):
+    """
+    Evaluate a model using specified measures given a filepath to database of songs.
+
+    Database must be formatted as follows:
+    [
+        #dict 1 for song 1
+        {
+            "id": (int) ...,
+            "prompt": (str) ...,                  #optional
+            "model_response": (str) ...,
+            "target_response": (str) ...          #optional
+        },
+        #dict 2 for song 2
+        {
+            " "
+        },
+        .
+        .
+        .
+    ]
+
+    Parameters
+    ----------
+    filepath : str
+        path to database .json file
+    measures : list
+        list of measures to evaluate model outputs, from {'diversity','meter','syllable'}
+    writeback : bool, optional
+        Whether to write evaluation scores to filepath or to output, by default False
+    outpath : str, optional
+        path to output .json file if writeback is False, by default ""
+
+    Raises
+    ------
+    FileNotFoundError
+    """
+    # read file
+    if os.path.exists(filepath):
+        with open(filepath, "r") as f:
+            database = json.load(f)
+    else:
+        raise FileNotFoundError(f"No such file exists: {filepath}")
+
+    if not writeback:
+        if not os.path.exists(outpath):
+            raise FileNotFoundError(f"No such file exists: {outpath}")
+    else:
+        outpath = filepath
+
+    # evaluate for measures
+    accumulator = ScoreAccumulator(
+        measures=measures,
+        require_prompt="prompt" in database[0],
+        require_target="target_response" in database[0],
+    )
+    accumulator.score_all_songs(database)
+
+    # print total scores
+    for measure in measures:
+        pred_score = accumulator.get_total_pred_score(measure)
+        target_score = accumulator.get_total_target_score(measure)
+        print(f"Score: pred {pred_score:2f}, target {target_score:2f} : ({measure})")
+
+    # save evaluation
+    out_database = []
+    for id, song_dict in accumulator._database.items():
+        song_dict["id"] = int(id)
+        out_database.append(song_dict)
+
+    with open(filepath, "w") as f:
+        f.write(json.dumps(out_database, indent=2, separators=[",", ":"]))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Evaluate a model given a filepath to a database of songs."
+    )
+    parser.add_argument(
+        "filepath", type=str, help="The path to the file to be processed"
+    )
+    parser.add_argument(
+        "--measures",
+        default=["diversity", "meter", "syllable"],
+        nargs="+",
+        help="List of measures to evaluate. From {'diversity','meter','syllable'}",
+    )
+    parser.add_argument(
+        "--writeback",
+        type=bool,
+        default=True,
+        help="Write evaluation scores back to the same dict or create a new one",
+    )
+    parser.add_argument(
+        "--output",
+        default="",
+        type=str,
+        help="The path to the write output scores if writeback is false",
+    )
+
+    args = parser.parse_args()
+    main(args.filepath, args.measures, args.writeback, args.output)

evaluation/meter_analysis.py

@@ -0,0 +1,47 @@
+import nltk
+import re
+import syllable_analysis as sylco
+import string
+
+nltk.download("cmudict")
+WORDS = nltk.corpus.cmudict.dict()
+
+
+def get_stress(word):
+    syllables = WORDS.get(word.lower())
+    if syllables:
+        stresses = "".join(
+            [phoneme[-1] for phoneme in syllables[0] if phoneme[-1].isdigit()]
+        )
+        return stresses
+    else:
+        return "Word not found in CMU Pronouncing Dictionary"
+
+
+def get_line_meter(line):
+    """Credit to https://stackoverflow.com/questions/9666838/"""
+
+    # Clean punctuation
+    exclude = set(string.punctuation)
+    exclude.remove("-")
+    line = "".join(ch for ch in line if ch not in exclude)
+
+    # stem words
+    words = re.split(r"[\s-]+", line)
+    stemmer = nltk.stem.SnowballStemmer("english")
+    stemmed_words = []
+    for word in words:
+        if word[-3:] == "ing" or word[-2:] == "ly":
+            stemmed_words.append(word)
+        else:
+            stemmed_words.append(stemmer.stem(word))
+
+    # get meter
+    line_stress = []
+    for word in stemmed_words:
+        if word not in WORDS:
+            line_stress.append("0" * sylco.count_syllables(word))
+        else:
+            line_stress.append(get_stress(word))
+
+    return map(str, line_stress)

evaluation/score_acculumator.py

@@ -0,0 +1,318 @@
+from collections import defaultdict, Counter
+import copy, pprint, re
+import itertools
+from tqdm import tqdm
+
+import scoring_metrics as metrics
+import text_processing_utils as text_utils
+
+
+class ScoreAccumulator(object):
+    def __init__(
+        self,
+        measures=["diversity"],
+        default_matching="",
+        require_prompt=False,
+        require_target=True,
+        verbose=True,
+    ):
+        """
+        Score accumulation object for measuring model inference performance
+        on a dataset of songs.
+
+        Capable of measuring:
+            Lexical diversity : "diversity"
+            Meter consistency : "meter"
+            Syllabic consistency : "syllable"
+
+        Parameters
+        ----------
+        measures : list, optional
+            list of measures to calculate for each song, by default ["diversity"]
+        default_matching : str
+            string defining the default stanza or line matching for comparison
+        require_prompt : bool, optional
+            whether to require the model prompt for each song, by default False
+        require_target : bool, optional
+            whether to requre a target response for each song, by default True
+        """
+        self.measures = measures
+        self.default_matching = default_matching
+        self.require_prompt = require_prompt
+        self.require_target = require_target
+        self.verbose = verbose
+
+        self.__total_score = Counter({measure: 0 for measure in self.measures})
+        self.__total_target_score = Counter({measure: 0 for measure in self.measures})
+        self._database = {}
+
+        self.measure_functions = {
+            "diversity": metrics.measure_lex_div,
+            "meter": metrics.measure_meter,
+            "syllable": metrics.measure_syllable,
+        }
+
+        supported_meas = {"diversity", "meter", "syllable"}
+        for measure in self.measures:
+            if measure not in {"diversity", "meter", "syllable"}:
+                raise NotImplementedError(f"Only measures {supported_meas} supported.")
+
+    def get_total_pred_score(self, measure):
+        """
+        Return current score totals of model predictions for a given
+        measure
+
+        Parameters
+        ----------
+        measure : str
+            measure to get score for
+
+        Returns
+        -------
+        float
+            average (by song) cumulative score
+        """
+        measure_score = self.__total_score[measure]
+        return measure_score / len(self._database)
+
+    def get_total_target_score(self, measure):
+        """
+        Return current score total of target responses for a given
+        measure
+
+        Parameters
+        ----------
+        measure : str
+            measure to get score for
+
+        Returns
+        -------
+        float
+            average (by song) cumulative score
+        """
+        measure_score = self.__total_target_score[measure]
+        return measure_score / len(self._database)
+
+    def get_ids(self):
+        return list(self._database.keys())
+
+    def get_prompts(self, ids=[]):
+        if ids:
+            return [self._database[id]["prompt"] for id in ids]
+        return [self._database[songid]["prompt"] for songid in self.get_ids]
+
+    def get_preds(self, ids=[]):
+        if ids:
+            return [self._database[id]["model_response"] for id in ids]
+        return [self._database[songid]["model_response"] for songid in self.get_ids]
+
+    def get_targets(self, ids=[]):
+        if ids:
+            return [self._database[id]["target_response"] for id in ids]
+        return [self._database[songid]["target_response"] for songid in self.get_ids]
+
+    def get_pred_scores(self, ids=[]):
+        if ids:
+            return [self._database[id]["pred_scores"] for id in ids]
+        return [self._database[songid]["pred_scores"] for songid in self.get_ids]
+
+    def get_target_scores(self, ids=[]):
+        if ids:
+            return [self._database[id]["target_scores"] for id in ids]
+        return [self._database[songid]["target_scores"] for songid in self.get_ids]
+
+    def score_all_songs(self, song_database):
+        """
+        Scores all songs in a song database (a list of song dictionaries) and adds
+        them to accumulators database.
+
+        Parameters
+        ----------
+        song_database : list
+            list of song dictionaries containing {id, prompt, model_response, and
+            target_response} keys
+        """
+        # TODO: add safety checks
+
+        for song_dict in tqdm(song_database, position=0):
+            self.score_song(song_dict)
+
+    def score_song(self, song_dict):
+        """
+        Adds song to accumulator and scores song.
+        Song dicts are formatted as follows:
+        {
+            id: unique id number,
+            prompt: prompt string,                      #if required
+            model_response: response from model,
+            target_response: ground truth text          #if required
+        }
+
+        Parameters
+        ----------
+        song_dict : dict
+            dict containing model predictions and targets for song
+        """
+        song_dict = copy.deepcopy(song_dict)
+        try:
+            id = song_dict["id"]
+            pred = song_dict["model_response"]
+            if self.require_prompt:
+                song_dict["prompt"]
+            if self.require_target:
+                target = song_dict["target_response"]
+        except Exception as e:
+            raise AssertionError(f"Provided song dict formatted incorrectly: {e}")
+
+        assert id not in self._database, f"Multiple entries found for unique id: {id}"
+
+        scores = {
+            "pred_scores": {measure: 0 for measure in self.measures},
+            "target_scores": {measure: 0 for measure in self.measures},
+        }
+        pred_stanzas, pred_matching = self.get_stanzas(pred, get_matching=True)
+        target_stanzas, target_matching = self.get_stanzas(target, get_matching=True)
+        for measure in (
+            tqdm(self.measures, position=1, leave=0) if self.verbose else self.measures
+        ):
+            scores["pred_scores"][measure] = self.measure_stanzas(
+                pred_stanzas,
+                self.measure_functions[measure],
+                matching=pred_matching if measure != "diversity" else "",
+            )
+            scores["target_scores"][measure] = self.measure_stanzas(
+                target_stanzas,
+                self.measure_functions[measure],
+                matching=target_matching if measure != "diversity" else "",
+            )
+
+        self.__total_score += Counter(scores["pred_scores"])
+        self.__total_target_score += Counter(scores["target_scores"])
+
+        song_dict.pop("id")
+        song_dict.update(scores)
+        self._database[id] = song_dict
+
+    def get_stanzas(self, song_text, get_matching=False):
+        """
+        Given the raw text of a song, gets the stanza paragraphs according to
+        their in-text label as {hook, verse, chorus, bridge, intro, outro}
+
+        Parameters
+        ----------
+        song_text : str
+            raw song text
+        get_matching : bool, optional,
+            whether to return a matching
+
+        Returns
+        -------
+        list : str
+            raw text, stripped of their stanza identifiers, split into stanzas
+        """
+        stanza_pairs = text_utils.get_stanzas(song_text)
+
+        matching_map = {}
+        matching_str = ""
+        match_idx = 0  # NOTE: using ints prohibits > 10 keywords per song
+
+        stanzas = []
+        for i, (kword, stanza) in enumerate(stanza_pairs):
+            assert match_idx < 10, "Stanza keywords are too complex, please simplify"
+            stanzas.append(
+                [n for n in stanza.split("\n") if len(re.sub(r"\s+", "", n)) > 0]
+            )
+
+            if i == 0:
+                matching_map[kword] = str(match_idx)
+                matching_str = str(match_idx)
+                match_idx += 1
+            elif kword in matching_map:
+                matching_str += "-" + matching_map[kword]
+            else:
+                matching_map[kword] = str(match_idx)
+                matching_str += "-" + matching_map[kword]
+                match_idx += 1
+
+        if get_matching:
+            return stanzas, matching_str
+        else:
+            return stanzas
+
+    def build_matches(self, stanzas, matching=""):
+        """
+        Builds matchings between stanzas given a matching string. If no matching
+        string provided, matchings are just the stanzas themselves.
+
+        Parameters
+        ----------
+        stanzas : list
+            list of input strings (stanzas) for different stanzas in a song
+        matching : str, optional
+            string defining the stanza or line matching for comparison, by default ""
+
+        Returns
+        -------
+        list
+            list of "matched" stanza pairings
+        """
+        if matching == "":
+            return [(s,) for s in stanzas]
+        matching = matching.split("-")
+        assert len(matching) == len(stanzas), "Incorrect matching to stanzas"
+
+        matches_dict = defaultdict(lambda: [])
+        pairings = []
+
+        # map stanzas to their matching char
+        for i, p in enumerate(stanzas):
+            matches_dict[matching[i]].append(p)
+
+        # build pairings
+        for matches in matches_dict.values():
+            for p1, p2 in itertools.combinations(matches, 2):
+                pairings.append([p1, p2])
+
+        return pairings
+
+    def measure_stanzas(self, stanzas, measure_function, matching=""):
+        """
+        Computes and returns a measure of a list of stanzas (string segments made up of numerous
+        lines). If measure is a consistency score, a comparison stanza is required.
+
+        Comparison metrics will be computed along the cartesian product of stanzas with matching
+        keys.
+
+        For example, given:
+            stanzas = ["line1", "line2", "line3", "line4"]
+            matching = "a-b-a-b"
+                -> Comparisons computed between [("line1", "line3"), ("line2", "line4")]
+
+        Parameters
+        ----------
+        stanzas : list
+            list of input strings (stanzas) for different stanzas in a song
+        measure_function : function
+            callable function that takes in a pairing and returns a float
+        matching : str
+            string defining the stanza or line matching for comparison
+
+        Returns
+        -------
+        float
+            averaged (across measurings) measure score
+        """
+        pairings = self.build_matches(stanzas, matching)
+
+        if len(pairings) == 0:
+            # NOTE: dangerous, since if no pairings the song structure could be fine..
+            return 0
+
+        score = 0
+
+        for pairing in pairings:
+            score += measure_function(*pairing)
+
+        final_score = score / len(pairings)
+
+        return final_score

evaluation/scoring_metrics.py

@@ -0,0 +1,234 @@
+import re
+import math
+import unidecode
+import copy
+from pprint import pp
+
+from lexical_diversity import lex_div as ld
+from dtaidistance import dtw
+from fastdtw import fastdtw
+import numpy as np
+
+import encode_lines as encode
+
+
+def measure_lex_div(p1, mode="mtld"):
+    """
+    Measure of lexical diversity of a set of lines
+
+    Parameters
+    ----------
+    p1 : list(str)
+        list of lines of paragraph or song as strings
+    mode : str, optional
+        lexical diversity metric, by default "mtld"
+
+    Returns
+    -------
+    float
+        lexical diversity score
+    """
+    lines = " ".join(p1)
+    flem_tokens = ld.flemmatize(unidecode.unidecode(lines))
+    if mode == "avg_ttr":
+        lex_div = ld.ttr(flem_tokens) / len(flem_tokens)
+    elif mode == "mtld":
+        lex_div = ld.mtld(flem_tokens)
+    elif mode == "avg_mtld":
+        lex_div = ld.mtld_ma_wrap(flem_tokens)
+    return lex_div
+
+
+def measure_meter(p1, p2):
+    """
+    Measure: meter consistency
+
+    Meter consistency between two lines or paragraphs is defined as the negative
+    exponential of the edit distance between their stress encodings.
+
+    Note that this mapping limits the "maximal" error, as extremely high syllable differences
+    will incur exponentially lower loss. The score is scaled between 0 and 100
+
+    Parameters
+    ----------
+    p1 : list
+        paragraph as a list of line strings
+    p2 : list
+        comparison paragraph as a list of line strings
+
+    Returns
+    -------
+    float
+        score of meter consistency
+    """
+    # encode into syllabic stress indicators
+    p1 = [encode.encode_line_meter_count(line) for line in p1]
+    p2 = [encode.encode_line_meter_count(line) for line in p2]
+
+    p1_string = "".join(line_stress for line_stress in p1).replace(" ", "").strip()
+    p2_string = "".join(line_stress for line_stress in p2).replace(" ", "").strip()
+
+    p1_string = re.sub(r"\s+", "", p1_string, flags=re.UNICODE)
+    p2_string = re.sub(r"\s+", "", p2_string, flags=re.UNICODE)
+
+    edit_dist = levenshteinDistance(p1_string, p2_string)
+    return edit_dist  # min(100, 100 / (edit_dist + 2e-7))  # math.exp(-0.1 * avg_edit_distance)
+
+
+def measure_syllable(p1: list, p2: list):
+    """
+    Measure: syllable consistency
+
+    We perform an altered version of the syllable DTW described in the methods
+    section of https://staff.aist.go.jp/m.goto/PAPER/TIEICE202309watanabe.pdf.
+    By recognizing that sometimes entire lines are out of "sync" between paragraphs,
+    we first minize the DTW via sliding window between the two paragraphs, then compute
+    the DTW line-by-line at the minimized offset.
+
+    Syllable consistency between two lines or paragraphs is defined as the
+    negative exponential of the DTW distance between two paragraph syllables.
+
+    Note that this mapping limits the "maximal" error, as extremely high syllable differences
+    will incur exponentially lower loss. The score is scaled between 0 and 100
+
+    Parameters
+    ----------
+    p1 : list
+        paragraph as a list of line strings
+    p2 : list
+        comparison paragraph as a list of line strings
+
+    Returns
+    -------
+    float
+        length-normalized syllabic consistency score
+    """
+    score = 0
+
+    # encode p1 and p2 into syllable counts
+    enc_fn = encode.encode_line_syllable_count
+
+    def encode_paragraph(par):
+        out = []
+        for line in par:
+            encoded_line = enc_fn(line).split(" ")
+            encoded_line = [word for word in encoded_line if word]
+            if len(encoded_line) == 0:
+                out.append([0])
+            else:
+                out.append(list(map(int, encoded_line)))
+        return out
+
+    p1, p2 = encode_paragraph(p1), encode_paragraph(p2)
+
+    # find and shift/crop p1 and p2 to the best matching offset
+    _, p1_c, p2_c = min_dtw_offset(p1, p2, return_cropped=True, use_short_window=True)
+
+    for i in range(len(p1_c)):
+        score += abs(sum(p1_c[i]) - sum(p2_c[i]))
+
+    return score  # min(100, 100 / (score + 2e-7))  # math.exp(-0.1 * score)
+
+
+def min_dtw_offset(p1, p2, return_cropped=True, use_short_window=True):
+    """
+    Use a sliding window (of lines) to find the line index offset which minimizes
+    the syllabic DTW between two paragraphs.
+
+    In addition to outside sliding window, setting inner_window > 0 allows for
+    an moving inner window across the smaller signal to find a cropping
+
+    Parameters
+    ----------
+    p1 : list
+        list of lists of song lines encoded as syllable counts
+    p2 : list
+        list of song lines encoded as syllable counts
+    return_cropped : bool, optional
+        whether to return the cropped min window for p1 and p2 ro the offset, by
+        default True
+    use_short_window : bool, optional
+        whether to compare at smaller or larger paragraphs length, by default true
+        Note: if False, p1 and p2 will not be the same length
+
+    Returns
+    -------
+    int
+        dtw minimizing offset value of smaller signal in larger signal
+    list
+        (p1) cropped or uncropped p1, squared with zeros
+    list
+        (p2) cropped or uncropped p2, squared with zeros
+    """
+    switched = False
+    if len(p1) < len(p2):
+        switched = True
+        p1, p2 = p2, p1
+
+    # crop or pad to same number of lines
+    win_length = len(p2) if use_short_window else len(p1)
+
+    # square by padding line lengths with zeros
+    sig1, sig2 = copy.deepcopy(p1), copy.deepcopy(p2)
+    max_val = max(max(len(l) for l in sig1), max(len(l) for l in sig2))
+    for i in range(len(p1)):
+        sig1[i] += [0] * (max_val - len(sig1[i]))
+    for i in range(len(p2)):
+        sig2[i] += [0] * (max_val - len(sig2[i]))
+    sig1, sig2 = np.sum(np.array(sig1), axis=1), np.sum(np.array(sig2), axis=1)
+
+    # compute dtw with a sliding window to find the best offset
+    sig1, sig2 = np.pad(sig1, (win_length, win_length)), sig2.astype(np.double)
+    min_idx, min_error = 0, np.inf
+    for j in range(sig1.shape[0] - win_length):
+        sig1_win = sig1[j : j + sig1.shape[0]].astype(np.double)
+
+        error = dtw.distance_fast(sig1_win, sig2, inner_dist="euclidean")
+
+        if error < min_error:
+            min_error = error
+            min_idx = j
+
+    # crop to window
+    if return_cropped:
+        p1 = [[0]] * win_length + p1 + [[0]] * win_length
+        p1 = p1[min_idx : min_idx + win_length]
+
+    if switched:
+        p1, p2 = p2, p1
+
+    return min_idx - win_length, p1, p2
+
+
+def levenshteinDistance(s1, s2):
+    """
+    DP edit distance implementation
+    credit to https://stackoverflow.com/questions/2460177
+
+    Parameters
+    ----------
+    s1 : str
+        first string to compare
+    s2 : str
+        second string to compare
+
+    Returns
+    -------
+    int
+        edit distance between two strings (absolute)
+    """
+    if len(s1) > len(s2):
+        s1, s2 = s2, s1
+
+    distances = range(len(s1) + 1)
+    for i2, c2 in enumerate(s2):
+        distances_ = [i2 + 1]
+        for i1, c1 in enumerate(s1):
+            if c1 == c2:
+                distances_.append(distances[i1])
+            else:
+                distances_.append(
+                    1 + min((distances[i1], distances[i1 + 1], distances_[-1]))
+                )
+        distances = distances_
+    return distances[-1]

evaluation/syllable_analysis.py

@@ -0,0 +1,207 @@
+import re
+from num2words import num2words
+
+SYL_DICT_PATH = "Syllables.txt"
+SYL_DICT = None
+
+
+def count_syllables(word):
+    global SYL_DICT
+    if SYL_DICT is None:
+        SYL_DICT = get_syllables_dict(SYL_DICT_PATH)
+
+    if word in SYL_DICT:
+        return SYL_DICT.get(word)["num_syllables"]
+    else:
+        return sylco(word)
+
+
+def get_syllables_dict(path):
+    with open(path, "r") as f:
+        lines = f.readlines()
+
+    duplicates = {}
+    syllable_dict = {}
+    for line in lines:
+        word, syllables = line.split("=")
+        syllables = [s for s in re.split("[^a-zA-Z]+", syllables) if len(s) > 0]
+
+        if word in syllable_dict:
+            duplicates[word] = 1
+        else:
+            syllable_dict[word] = {
+                "num_syllables": len(syllables),
+                "suffixes": syllables,
+            }
+
+    return syllable_dict
+
+
+def replace_numbers_with_words(text):
+    def replace_match(match):
+        number = int(match.group())
+        return num2words(number)
+
+    return re.sub(r"\b\d+\b", replace_match, text)
+
+
+def sylco(word):
+    """Credit to https://stackoverflow.com/questions/46759492/"""
+    word = word.lower()
+    word = replace_numbers_with_words(word)
+
+    # exception_add are words that need extra syllables
+    # exception_del are words that need less syllables
+
+    exception_add = ["serious", "crucial"]
+    exception_del = ["fortunately", "unfortunately"]
+
+    co_one = [
+        "cool",
+        "coach",
+        "coat",
+        "coal",
+        "count",
+        "coin",
+        "coarse",
+        "coup",
+        "coif",
+        "cook",
+        "coign",
+        "coiffe",
+        "coof",
+        "court",
+    ]
+    co_two = ["coapt", "coed", "coinci"]
+
+    pre_one = ["preach"]
+
+    syls = 0  # added syllable number
+    disc = 0  # discarded syllable number
+
+    # 1) if letters < 3 : return 1
+    if len(word) <= 3:
+        syls = 1
+        return syls
+
+    # 2) if doesn't end with "ted" or "tes" or "ses" or "ied" or "ies", discard "es" and "ed" at the end.
+    # if it has only 1 vowel or 1 set of consecutive vowels, discard. (like "speed", "fled" etc.)
+
+    if word[-2:] == "es" or word[-2:] == "ed":
+        doubleAndtripple_1 = len(re.findall(r"[eaoui][eaoui]", word))
+        if doubleAndtripple_1 > 1 or len(re.findall(r"[eaoui][^eaoui]", word)) > 1:
+            if (
+                word[-3:] == "ted"
+                or word[-3:] == "tes"
+                or word[-3:] == "ses"
+                or word[-3:] == "ied"
+                or word[-3:] == "ies"
+            ):
+                pass
+            else:
+                disc += 1
+
+    # 3) discard trailing "e", except where ending is "le"
+
+    le_except = [
+        "whole",
+        "mobile",
+        "pole",
+        "male",
+        "female",
+        "hale",
+        "pale",
+        "tale",
+        "sale",
+        "aisle",
+        "whale",
+        "while",
+    ]
+
+    if word[-1:] == "e":
+        if word[-2:] == "le" and word not in le_except:
+            pass
+
+        else:
+            disc += 1
+
+    # 4) check if consecutive vowels exists, triplets or pairs, count them as one.
+
+    doubleAndtripple = len(re.findall(r"[eaoui][eaoui]", word))
+    tripple = len(re.findall(r"[eaoui][eaoui][eaoui]", word))
+    disc += doubleAndtripple + tripple
+
+    # 5) count remaining vowels in word.
+    numVowels = len(re.findall(r"[eaoui]", word))
+
+    # 6) add one if starts with "mc"
+    if word[:2] == "mc":
+        syls += 1
+
+    # 7) add one if ends with "y" but is not surrouned by vowel
+    if word[-1:] == "y" and word[-2] not in "aeoui":
+        syls += 1
+
+    # 8) add one if "y" is surrounded by non-vowels and is not in the last word.
+
+    for i, j in enumerate(word):
+        if j == "y":
+            if (i != 0) and (i != len(word) - 1):
+                if word[i - 1] not in "aeoui" and word[i + 1] not in "aeoui":
+                    syls += 1
+
+    # 9) if starts with "tri-" or "bi-" and is followed by a vowel, add one.
+
+    if word[:3] == "tri" and word[3] in "aeoui":
+        syls += 1
+
+    if word[:2] == "bi" and word[2] in "aeoui":
+        syls += 1
+
+    # 10) if ends with "-ian", should be counted as two syllables, except for "-tian" and "-cian"
+
+    if word[-3:] == "ian":
+        # and (word[-4:] != "cian" or word[-4:] != "tian") :
+        if word[-4:] == "cian" or word[-4:] == "tian":
+            pass
+        else:
+            syls += 1
+
+    # 11) if starts with "co-" and is followed by a vowel, check if exists in the double syllable dictionary, if not, check if in single dictionary and act accordingly.
+
+    if word[:2] == "co" and word[2] in "eaoui":
+        if word[:4] in co_two or word[:5] in co_two or word[:6] in co_two:
+            syls += 1
+        elif word[:4] in co_one or word[:5] in co_one or word[:6] in co_one:
+            pass
+        else:
+            syls += 1
+
+    # 12) if starts with "pre-" and is followed by a vowel, check if exists in the double syllable dictionary, if not, check if in single dictionary and act accordingly.
+
+    if word[:3] == "pre" and word[3] in "eaoui":
+        if word[:6] in pre_one:
+            pass
+        else:
+            syls += 1
+
+    # 13) check for "-n't" and cross match with dictionary to add syllable.
+
+    negative = ["doesn't", "isn't", "shouldn't", "couldn't", "wouldn't"]
+
+    if word[-3:] == "n't":
+        if word in negative:
+            syls += 1
+        else:
+            pass
+
+    # 14) Handling the exceptional words.
+
+    if word in exception_del:
+        disc += 1
+
+    if word in exception_add:
+        syls += 1
+
+    # calculate the output
+    return numVowels - disc + syls

evaluation/text_processing_utils.py

@@ -0,0 +1,124 @@
+import re
+from unidecode import unidecode
+
+STANZA_KEYWORDS = {
+    "pre-hook",
+    "post-hook",
+    "pre-drop",
+    "pre-chorus",
+    "post-chorus",
+    "pre-coro",
+    "post-coro",
+    "breakdown",
+    "drop",
+    "hook",
+    "verse",
+    "chorus",
+    "bridge",
+    "intro",
+    "outro",
+    "refrain",
+    "guitar solo",
+    "solo",
+    "letra de",
+    "instrumental",
+    "verso",
+    "coro",
+    "couplet",
+    "pont",
+    "ponte",
+    "interlude",
+    "part",
+    "refrão",
+}
+
+
+def get_kword(delin):
+    """Gets kword readable string from matched delineator"""
+    delin = delin.split(":")[0]
+    delin = re.sub(r"\d+", "", delin)
+    return delin.strip()
+
+
+def clean_song(text):
+    """
+    Custom rules for "cleaning" the song data to disambiguate stanza
+    delineators
+
+    Parameters
+    ----------
+    text : str
+        raw song data
+
+    Returns
+    -------
+    str
+        cleaned song data
+    """
+    text = unidecode(text).lower()
+
+    # Replace all "[?]", "[chuckles]", "[laughs]", "[Mumbling]" with "nan"
+    text = re.sub(r"\[\?\]|\[chuckles\]|\[laughs\]|\[Mumbling\]", "nan", text)
+
+    # Replace all "]:" with "]\n"
+    text = re.sub(r"\]:", "]\n", text)
+
+    # Replace all "[X]" with "nan" where X is any number of "." characters
+    text = re.sub(r"\[\.*?\]", "nan", text)
+
+    # For any remaining bracketed texts replace with kword readable string and add a newline
+    def replace_bracketed(match):
+        kword = get_kword(match.group(1))
+        return f"\n[{kword}]\n"
+
+    text = re.sub(r"\[([\s\S]*?)\]", replace_bracketed, text)
+
+    return text
+
+
+def get_stanzas(text):
+    """
+    Process song as raw text to return a list of stanza - keyword pairings.
+    If keyword match is unidentified, pairs with entire match rather than just the
+    known keyword
+
+    Parameters
+    ----------
+    text : str
+        raw song text
+
+    Returns
+    -------
+    list(tuple)
+        list of tuple (keyword, stanza_text) pairings
+    """
+    stanzas = []
+    text = clean_song(text)
+
+    # Find all identifiers inside brackets
+    matches = re.findall(r"\[([\s\S]*?)\]", text)
+    split_text = re.split(r"\[(?:[\s\S]*?)\]", text)[1:]
+
+    # pair text in stanzas with existing keyword or new match
+    for i, match in enumerate(matches):
+        matched_with_kword = False
+
+        for keyword in STANZA_KEYWORDS:
+            if match.startswith(keyword):
+                stanzas.append((keyword, split_text[i]))
+                matched_with_kword = True
+                break
+
+        if not matched_with_kword:
+            stanzas.append((match, split_text[i]))
+
+    # remove empty stanzas
+    stanzas = [(keyword, stanza) for keyword, stanza in stanzas if stanza.strip()]
+
+    return stanzas
+
+
+def find_surrounding_chars(text, pattern, before=50, after=50):
+    """Helpful testing utility"""
+    regex_pattern = f".{{0,{before}}}{pattern}.{{0,{after}}}"
+    return re.findall(regex_pattern, text)