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

Feel free to look over this and try it yourself, but it's like 800 lines or something so don't feel pressured to review too deeply.

I'm leaning on methods described in the Structural Feature extraction section of this paper: https://staff.aist.go.jp/m.goto/PAPER/TIEICE202309watanabe.pdf. There's no public implementation of it though, so everything here is just reimplemented from scratch (potentially buggy).

Basically the way it works is I've defined a ScoreAccumulator that evaluates a bunch of metrics (either "comparison" or "non-comparison") on the target and prediction text.
- Comparison metrics compare the structure of similar stanzas as defined by the model/target data. For example if the two stanzas are labeled "chorus", then they will be compared with eachother but not the verses, and similarly for other stanza labels. I extracted like 30 different stanza labels in english and spanish from the data (see text_processing_utils.py), making this a bit hacky, so feel free to contribute ideas.
- Non-comparison metrics (currently the only one is lexical diversity via mltd) are just run over the entire text.

NOTE: Currently function requires that stanzas are delineated by [<delineator (verse, chorus, etc) <something here>]. Some model outputs (llama) delineate by (), which creates an ambiguity problem as "()" is used in actual lyrics with highly variable text strings inside.

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)