processor (#1)

- Script used for processing of raw json annotations (10774be0623a30d27a1eb968d8b6e588b8d53c34)

processor.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python
+
+import json
+import argparse
+import random
+import os
+import pandas as pd
+import datasets
+
+# Annotation file structure
+# {
+#     "username": <str>,
+#     "fail_reason": {
+#         "text": <str>,
+#         "vote": <int>
+#     },
+#     "how_to_fix": {
+#         "text": <str>,
+#         "vote": <int>
+#     },
+#     "snippets": [
+#         {
+#             "text": <str>,
+#             "comment": <str>,
+#             "file": <str>,
+#             "color": <hex>,
+#             "vote": 0,
+#             "start_index": <int>,
+#             "end_index": <int>
+#         },
+#     ],
+#     "id": <str>
+# }
+
+SNIPPET_USER_MSG = """Analyse following RPM build log snippet. Describe contents accurately, without speculation or suggestions for resolution.            
+Your analysis must be as concise as possible, while keeping relevant information intact.
+Snippet: 
+{}"""
+
+FULL_CONVERSATION_MSG = """Given following log snippets, their explanation, and nothing else, explain what failure, if any, occurred during build of this package.
+
+  Snippets are in a format of [X] : [Y], where [X] is a log snippet, and [Y] is the explanation.
+
+  Snippets are delimited with '================'.
+
+  Drawing on information from all snippets, provide a concise explanation of the issue and recommend a solution.
+
+  Explanation of the issue, and recommended solution, should take a handful of sentences.
+
+  Snippets:
+
+  {}
+"""
+
+ANALYSIS_MSG = "Issue: {issue}\nResolution: {resolution}"
+
+def n_snippets(logs: dict):
+    """Count number of snippets in a log."""
+    cnt = 0
+    for log in logs:
+        if logs[log]:
+            cnt += len(logs[log]["snippets"])
+    return cnt
+
+
+def none_snippet(logs: dict):
+    """Presence of snippet with text set to `None`"""
+    for log in logs:
+        if logs[log]:
+            for snippet in logs[log]["snippets"]:
+                if not snippet["text"]:
+                    return True
+    return False
+
+
+def total_snippet_annotation_len(logs: dict):
+    """Total length of snippet annotations"""
+    total = 0
+    for log in logs:
+        if logs[log]:
+            for snippet in logs[log]["snippets"]:
+                if snippet["user_comment"]:
+                    total += len(snippet["user_comment"])
+    return total
+
+
+def fix_snippets(logs: dict):
+    """Set snippet text to equal log content delimited by indices"""
+    for log in logs:
+        if logs[log]:
+            for snippet in logs[log]["snippets"]:
+                snippet_text = logs[log]["content"][snippet["start_index"]:snippet["end_index"]]
+                if "text" not in snippet or not snippet["text"]:
+                    snippet["text"] = snippet_text
+    return logs
+
+
+def cleanup(dataset: pd.DataFrame):
+    """Cleaning the dataset
+
+    For sake of simplicity we are going to assume following.
+
+    1. Descriptions of issues and fixes shorter than `10` chars are not useful.
+    2. Submissions without annotated snippets are not useful.
+    3. Submissions with total length of snippet annotations shorter than `10` chars are not useful.
+    4. Submissions with snippets set to `None` are not useful."""
+
+    # Fixing snippets with messed up text
+    filled_snippets = dataset.logs.apply(fix_snippets)
+    dataset['filled_snippets'] = filled_snippets
+    dataset.logs = dataset.filled_snippets
+
+    # Setting conditional columns
+    dataset['how_to_fix_len'] = dataset.how_to_fix.apply(len)
+    dataset['fail_reason_len'] = dataset.fail_reason.apply(len)
+    dataset["tot_snippet_annot_len"] = dataset['logs'].apply(total_snippet_annotation_len)
+
+    # Conditions
+    almost_empty_fix = dataset['how_to_fix_len'] < 10
+    almost_empty_reason = dataset['fail_reason_len'] < 10
+    almost_empty_snippet_annotations = dataset["tot_snippet_annot_len"] < 10
+    none_snippets = dataset['logs'].apply(none_snippet)
+
+    sparse_annotation_criteria = (
+        almost_empty_snippet_annotations |
+        almost_empty_reason |
+        almost_empty_fix |
+        none_snippets)
+
+    sparse_count = dataset[sparse_annotation_criteria].shape[0]
+    print(
+        f"Total sparse annotations: {sparse_count} \
+        Relative to original dataset: {sparse_count / dataset.shape[0]}")
+
+    # Applying filters
+    final_dataset = dataset[~sparse_annotation_criteria]
+    final_dataset.reindex()
+
+    return final_dataset
+
+
+def save_dataset(dataset: pd.DataFrame, path: str):
+    """Turn dataframe into parquet"""
+    dataset.to_parquet(path)
+
+
+def load_data(data_path: str):
+    """Load json files and return them as list of dicts"""
+    data = []
+    for root, _, files in os.walk(data_path):
+        for file in files:
+            if file.endswith(".json"):
+                with open(os.path.join(root, file), 'r', encoding='utf-8') as f:
+                    parsed_data = json.load(f)
+                    parsed_data["file_name"] = file
+                    data.append(parsed_data)
+
+    return data
+
+
+def make_snippet_qa(snippet: dict, user_message_template: str):
+    """Create a QnA pair from a snippet"""
+    return {
+        "question": user_message_template.format(snippet["text"]),
+        "answer": snippet["user_comment"]
+    }
+
+
+def make_analysis_qa(snippets, issue, resolution, user_message_template,
+                     analysis_template):
+    """Create QnA pair from entire annotation."""
+    formatted_snippets = "\n=============\n".join(
+        [
+            f'[{e["text"]}]: [{e["user_comment"]}]'
+            for e in snippets
+        ]
+    )
+
+    return {
+        "question": user_message_template.format(formatted_snippets),
+        "answer": analysis_template.format(issue=issue, resolution=resolution)
+    }
+
+
+def to_qa_pairs(dataframe: pd.DataFrame):
+    """Turn dataframe into list of QnA pairs for training."""
+    qa_pairs = []
+
+    for row in dataframe.iterrows():
+        sample_snippet_messages = []
+
+        # First element is index
+        data = row[1]
+
+        logfiles = data.logs
+        # All annoted snippets will be used for final analysis
+        annotated_snippets = []
+        for file in logfiles:
+            if logfiles[file] and "snippets" in logfiles[file]:
+                for snippet in logfiles[file]["snippets"]:
+                    sample_snippet_messages.append(
+                        make_snippet_qa(
+                            snippet,
+                            SNIPPET_USER_MSG)
+                    )
+                    annotated_snippets.append(snippet)
+        qa_pairs.append(
+            make_analysis_qa(
+                annotated_snippets,
+                data.fail_reason,
+                data.how_to_fix,
+                FULL_CONVERSATION_MSG,
+                ANALYSIS_MSG))
+        # Adding individual snippet messages
+        qa_pairs.extend(sample_snippet_messages)
+    return qa_pairs
+
+
+def split_dataset(dataset: pd.DataFrame, seed: int):
+    """Splits dataset into training and evaluation subset"""
+    split = dataset.shape[0] // 5
+    dataset = dataset.sample(frac=1.0, random_state=seed)
+    train_dataset, test_dataset =  dataset[split:], dataset[:split]
+
+    return train_dataset, test_dataset
+
+
+def main(hf_token, data_path="results/results", sanitize=True,
+         seed=42, repo_id="fedora-copr/log_detective_qna",
+        ):
+    """Process entire directory and turn contents into parquet files."""
+
+    # For reproducibility
+    random.seed = seed
+
+    data = load_data(data_path)
+    full_dataset = pd.DataFrame.from_records(data)
+
+    if sanitize:
+        full_dataset = cleanup(full_dataset)
+
+    # Split dataset
+    train_dataset, test_dataset = split_dataset(full_dataset, seed)
+
+    # Format as QnA pairs
+    train_dataset, test_dataset = to_qa_pairs(train_dataset), to_qa_pairs(test_dataset)
+
+    dataset = {
+        "train": datasets.Dataset.from_list(train_dataset),
+        "test": datasets.Dataset.from_list(test_dataset)}
+
+    dataset = datasets.DatasetDict(dataset)
+
+    dataset.push_to_hub(repo_id=repo_id, private=True, token=hf_token)
+
+    print("Saving full dataset as parquet...")
+    save_dataset(full_dataset, "full_dataset.parquet")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("Dataset Processor")
+    parser.add_argument(
+        "data_path", type=str, default="results/results", help="Path to annotations.")
+    parser.add_argument(
+        "--sanitize", type=bool, default=True, help="Run basic data cleanup procedure")
+    parser.add_argument(
+        "--seed", type=int, default=42,
+        help="Seed for random generator to be used when generating split.")
+    parser.add_argument(
+        "--repo_id", type=str, default="fedora-copr/log_detective_qna",
+        help="ID of Hugging Face repo")
+    parser.add_argument("--token", type=str, required=True, help="Token for Hugging face")
+    args = parser.parse_args()
+
+    main(
+        data_path=args.data_path, sanitize=args.sanitize,
+        seed=args.seed, repo_id=args.repo_id, hf_token=args.token)