| 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 |
| """ |
| |
|
|
| 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 |
|
|
| 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 = [] |
|
|
| |
| for i, p in enumerate(stanzas): |
| matches_dict[matching[i]].append(p) |
|
|
| |
| 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: |
| |
| return 0 |
|
|
| score = 0 |
|
|
| for pairing in pairings: |
| score += measure_function(*pairing) |
|
|
| final_score = score / len(pairings) |
|
|
| return final_score |
|
|
