Copy over the code from the blog post

src/convert.py

@@ -0,0 +1,331 @@
+import ast
+import re
+from dataclasses import dataclass
+from typing import Optional, TypedDict
+
+import Levenshtein
+import pandas as pd
+
+
+def read_sem_eval_file(file: str) -> pd.DataFrame:
+    df = pd.read_xml(file)[["text"]]
+    return df
+
+
+def read_aste_file(file: str) -> pd.DataFrame:
+    def triple_to_hashable(
+        triple: tuple[list[int], list[int], str]
+    ) -> tuple[tuple[int, ...], tuple[int, ...], str]:
+        aspect_span, opinion_span, sentiment = triple
+        return tuple(aspect_span), tuple(opinion_span), sentiment
+
+    df = pd.read_csv(
+        file,
+        sep="####",
+        header=None,
+        names=["text", "triples"],
+        engine="python",
+    )
+
+    # There are duplicate rows, some of which have the same triples and some don't
+    # This deals with that by
+    # * first dropping the pure duplicates,
+    # * then parsing the triples and exploding them to one per row
+    # * then dropping the exploded duplicates (have to convert triples back to string for this)
+    # * then grouping the triples up again
+    # * finally sorting the distinct triples
+
+    # df = df.copy()
+    df = df.drop_duplicates()
+    df["triples"] = df.triples.apply(ast.literal_eval)
+    df = df.explode("triples")
+    df["triples"] = df.triples.apply(triple_to_hashable)
+    df = df.drop_duplicates()
+    df = df.groupby("text").agg(list)
+    df = df.reset_index(drop=False)
+    df["triples"] = df.triples.apply(set).apply(sorted)
+
+    return df
+
+
+def get_original_text(
+    aste_file: str,
+    sem_eval_file: str,
+    debug: bool = False,
+) -> pd.DataFrame:
+    approximate_matches = 0
+
+    def best_match(text: str) -> str:
+        comparison = text.replace(" ", "")
+        if comparison in comparison_to_text:
+            return comparison_to_text[comparison]
+
+        nonlocal approximate_matches
+        approximate_matches += 1
+        distances = sem_eval_comparison.apply(
+            lambda se_comparison: Levenshtein.distance(comparison, se_comparison)
+        )
+        best = sem_eval_df.iloc[distances.argmin()].text
+        return best
+
+    sem_eval_df = read_sem_eval_file(sem_eval_file)
+    sem_eval_comparison = sem_eval_df.text.str.replace(" ", "")
+    comparison_to_text = dict(zip(sem_eval_comparison, sem_eval_df.text))
+
+    aste_df = read_aste_file(aste_file)
+    aste_df = aste_df.rename(columns={"text": "preprocessed_text"})
+    aste_df["text"] = aste_df.preprocessed_text.apply(best_match)
+    if debug:
+        print(f"Read {len(aste_df):,} rows")
+        print(f"Had to use {approximate_matches:,} approximate matches")
+    return aste_df[["text", "preprocessed_text", "triples"]]
+
+
+def edit(original: str, preprocessed: str) -> list[Optional[int]]:
+    indices: list[Optional[int]] = list(range(len(preprocessed)))
+    for operation, _source_position, destination_position in Levenshtein.editops(
+        preprocessed, original
+    ):
+        if operation == "replace":
+            indices[destination_position] = None
+        elif operation == "insert":
+            indices.insert(destination_position, None)
+        elif operation == "delete":
+            del indices[destination_position]
+    return indices
+
+
+def has_unmapped(indicies: list[Optional[int]]) -> bool:
+    return any(index is None for index in indicies)
+
+
+def has_unmapped_non_space(row: pd.Series) -> bool:
+    letter_and_index: list[tuple[str, Optional[int]]] = list(
+        zip(row.text, row.text_indices)
+    )
+    return any(index is None for letter, index in letter_and_index if letter != " ")
+
+
+@dataclass(frozen=True)
+class WordSpan:
+    start_index: int
+    end_index: int  # this is the letter after the end
+
+
+class CharacterIndices(TypedDict):
+    aspect_start_index: int
+    aspect_end_index: int
+    aspect_term: str
+    opinion_start_index: int
+    opinion_end_index: int
+    opinion_term: str
+    sentiment: str
+
+
+word_pattern = re.compile(r"\S+")
+
+
+def row_to_character_indices(row: pd.Series) -> pd.Series:
+    try:
+        return pd.Series(
+            to_character_indices(
+                triplet=row.triples,
+                preprocessed=row.preprocessed_text,
+                text=row.text,
+                text_indices=row.text_indices,
+            )
+        )
+    except:
+        print(f"failed to process row {row.name}")
+        print(row)
+        raise
+
+
+def to_character_indices(
+    *,
+    triplet: tuple[tuple[int], tuple[int], str],
+    preprocessed: str,
+    text: str,
+    text_indices: list[Optional[int]],
+) -> CharacterIndices:
+    def find_start_index(span: WordSpan) -> int:
+        # the starting letter in the lookup can be missing or None
+        # this would cause a lookup failure
+        # to recover from this we can find the following letter index and backtrack
+        for index in range(span.start_index, span.end_index):
+            try:
+                text_index = text_indices.index(index)
+                for _ in range(index - span.start_index):
+                    if text_index - 1 <= 0:
+                        break
+                    if text_indices[text_index - 1] is not None:
+                        break
+                    text_index -= 1
+                return text_index
+            except ValueError:
+                pass
+                # not present in list
+        raise ValueError(f"cannot find any part of {span}")
+
+    def find_end_index(span: WordSpan) -> int:
+        # the ending letter in the lookup can be missing or None
+        # this would cause a lookup failure
+        # to recover from this we can find the preceding letter index and backtrack
+        for index in range(span.end_index - 1, span.start_index - 1, -1):
+            try:
+                text_index = text_indices.index(index)
+                for _ in range(span.end_index - index):
+                    if text_index + 1 >= len(text_indices):
+                        break
+                    if text_indices[text_index + 1] is not None:
+                        break
+                    text_index += 1
+                return text_index
+            except ValueError:
+                pass
+                # not present in list
+        raise ValueError(f"cannot find any part of {span}")
+
+    def to_indices(span: tuple[int]) -> tuple[int, int]:
+        word_start = span[0]
+        word_start_span = word_indices[word_start]
+
+        word_end = span[-1]
+        word_end_span = word_indices[word_end]
+
+        start_index = find_start_index(word_start_span)
+        end_index = find_end_index(word_end_span)
+        return start_index, end_index
+
+    aspect_span, opinion_span, sentiment = triplet
+    assert is_sequential(aspect_span), f"aspect span not sequential: {aspect_span}"
+    assert is_sequential(opinion_span), f"opinion span not sequential: {opinion_span}"
+    assert sentiment in {"POS", "NEG", "NEU"}, f"unknown sentiment: {sentiment}"
+
+    word_indices = [
+        WordSpan(start_index=match.start(), end_index=match.end())
+        for match in word_pattern.finditer(preprocessed)
+    ]
+
+    aspect_start_index, aspect_end_index = to_indices(aspect_span)
+    aspect_term = text[aspect_start_index : aspect_end_index + 1]
+    opinion_start_index, opinion_end_index = to_indices(opinion_span)
+    opinion_term = text[opinion_start_index : opinion_end_index + 1]
+
+    nice_sentiment = {
+        "POS": "positive",
+        "NEG": "negative",
+        "NEU": "neutral",
+    }[sentiment]
+
+    return {
+        "aspect_start_index": aspect_start_index,
+        "aspect_end_index": aspect_end_index,
+        "aspect_term": aspect_term,
+        "opinion_start_index": opinion_start_index,
+        "opinion_end_index": opinion_end_index,
+        "opinion_term": opinion_term,
+        "sentiment": nice_sentiment,
+    }
+
+
+def convert_sem_eval_text(
+    aste_file: str,
+    sem_eval_file: str,
+    debug: bool = False,
+) -> pd.DataFrame:
+    df = get_original_text(
+        aste_file=aste_file,
+        sem_eval_file=sem_eval_file,
+        debug=debug,
+    )
+    df = df.explode("triples")
+    df = df.reset_index(drop=False)
+    df["text_indices"] = df.apply(
+        lambda row: edit(original=row.text, preprocessed=row.preprocessed_text),
+        axis="columns",
+    )
+    df = df.merge(
+        df.apply(row_to_character_indices, axis="columns"),
+        left_index=True,
+        right_index=True,
+    )
+    df = df.drop(columns=["preprocessed_text", "triples", "text_indices"])
+    return df
+
+
+def convert_aste_text(aste_file: str) -> pd.DataFrame:
+    df = read_aste_file(aste_file)
+    df = df.explode("triples")
+    df = df.reset_index(drop=False)
+    df = df.merge(
+        df.apply(aste_row_to_character_indices, axis="columns"),
+        left_index=True,
+        right_index=True,
+    )
+    df = df.drop(columns=["triples"])
+    return df
+
+
+def aste_row_to_character_indices(row: pd.Series) -> pd.Series:
+    try:
+        return pd.Series(
+            aste_to_character_indices(
+                triplet=row.triples,
+                text=row.text,
+            )
+        )
+    except:
+        print(f"failed to process row {row.name}")
+        print(row)
+        raise
+
+
+def is_sequential(span: tuple[int]) -> bool:
+    return all(span[index + 1] - span[index] == 1 for index in range(len(span) - 1))
+
+
+def aste_to_character_indices(
+    *,
+    triplet: tuple[tuple[int], tuple[int], str],
+    text: str,
+) -> CharacterIndices:
+    def to_indices(span: tuple[int]) -> tuple[int, int]:
+        word_start = span[0]
+        word_start_span = word_indices[word_start]
+
+        word_end = span[-1]
+        word_end_span = word_indices[word_end]
+
+        return word_start_span.start_index, word_end_span.end_index - 1
+
+    aspect_span, opinion_span, sentiment = triplet
+    assert is_sequential(aspect_span), f"aspect span not sequential: {aspect_span}"
+    assert is_sequential(opinion_span), f"opinion span not sequential: {opinion_span}"
+    assert sentiment in {"POS", "NEG", "NEU"}, f"unknown sentiment: {sentiment}"
+
+    word_indices = [
+        WordSpan(start_index=match.start(), end_index=match.end())
+        for match in word_pattern.finditer(text)
+    ]
+
+    aspect_start_index, aspect_end_index = to_indices(aspect_span)
+    aspect_term = text[aspect_start_index : aspect_end_index + 1]
+    opinion_start_index, opinion_end_index = to_indices(opinion_span)
+    opinion_term = text[opinion_start_index : opinion_end_index + 1]
+
+    nice_sentiment = {
+        "POS": "positive",
+        "NEG": "negative",
+        "NEU": "neutral",
+    }[sentiment]
+
+    return {
+        "aspect_start_index": aspect_start_index,
+        "aspect_end_index": aspect_end_index,
+        "aspect_term": aspect_term,
+        "opinion_start_index": opinion_start_index,
+        "opinion_end_index": opinion_end_index,
+        "opinion_term": opinion_term,
+        "sentiment": nice_sentiment,
+    }