Add dataset

README.md

@@ -0,0 +1,156 @@
+---
+annotations_creators:
+- found
+language_creators:
+- found
+language:
+- en
+- nl
+license:
+- unknown
+multilinguality:
+- multilingual
+size_categories:
+- 10K<n<100K
+- 1M<n<10M
+- n<1K
+source_datasets:
+- original
+task_categories:
+- translation
+task_ids: []
+pretty_name: OpenSubtitles En Nl
+---
+
+# Dataset Card for OpenSubtitles
+
+## Table of Contents
+- [Dataset Description](#dataset-description)
+  - [Dataset Summary](#dataset-summary)
+  - [Supported Tasks and Leaderboards](#supported-tasks-and-leaderboards)
+  - [Languages](#languages)
+- [Dataset Structure](#dataset-structure)
+  - [Data Instances](#data-instances)
+  - [Data Fields](#data-fields)
+  - [Data Splits](#data-splits)
+- [Dataset Creation](#dataset-creation)
+  - [Curation Rationale](#curation-rationale)
+  - [Source Data](#source-data)
+  - [Annotations](#annotations)
+  - [Personal and Sensitive Information](#personal-and-sensitive-information)
+- [Considerations for Using the Data](#considerations-for-using-the-data)
+  - [Social Impact of Dataset](#social-impact-of-dataset)
+  - [Discussion of Biases](#discussion-of-biases)
+  - [Other Known Limitations](#other-known-limitations)
+- [Additional Information](#additional-information)
+  - [Dataset Curators](#dataset-curators)
+  - [Licensing Information](#licensing-information)
+  - [Citation Information](#citation-information)
+  - [Contributions](#contributions)
+
+## Dataset Description
+
+- **Homepage:** http://opus.nlpl.eu/OpenSubtitles.php
+- **Repository:** None
+- **Paper:** http://www.lrec-conf.org/proceedings/lrec2016/pdf/62_Paper.pdf
+- **Leaderboard:** [More Information Needed]
+- **Point of Contact:** [More Information Needed]
+
+### Dataset Summary
+
+This dataset is a subset from the en-nl open_subtitles dataset.
+It contains only subtitles of tv shows that have a rating of at least 8.0 with at least 1000 votes.
+The subtitles are also ordered and appended into buffers several lengths, with a maximum of 370 tokens
+as tokenized by the 'yhavinga/ul2-base-dutch' tokenizer.
+
+
+### Supported Tasks and Leaderboards
+
+[More Information Needed]
+
+### Languages
+
+The languages in the dataset are:
+- en
+- nl
+
+## Dataset Structure
+
+### Data Instances
+
+Here are some examples of questions and facts:
+
+
+### Data Fields
+
+[More Information Needed]
+
+### Data Splits
+
+[More Information Needed]
+
+## Dataset Creation
+
+### Curation Rationale
+
+[More Information Needed]
+
+### Source Data
+
+[More Information Needed]
+
+#### Initial Data Collection and Normalization
+
+[More Information Needed]
+
+#### Who are the source language producers?
+
+[More Information Needed]
+
+### Annotations
+
+[More Information Needed]
+
+#### Annotation process
+
+[More Information Needed]
+
+#### Who are the annotators?
+
+[More Information Needed]
+
+### Personal and Sensitive Information
+
+[More Information Needed]
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+[More Information Needed]
+
+### Discussion of Biases
+
+[More Information Needed]
+
+### Other Known Limitations
+
+[More Information Needed]
+
+## Additional Information
+
+### Dataset Curators
+
+[More Information Needed]
+
+### Licensing Information
+
+[More Information Needed]
+
+### Citation Information
+
+[More Information Needed]
+
+### Contributions
+
+Thanks to [@abhishekkrthakur](https://github.com/abhishekkrthakur) for adding the open_subtitles dataset.

src/create_dataset.py

@@ -0,0 +1,168 @@
+import gzip
+import json
+
+import numpy as np
+import pandas as pd
+from transformers import AutoTokenizer
+
+COLLATE_LENGTH = 370
+
+
+def emit(line_id, nl_str, en_str, nl_l, en_l):
+    obj = {
+        "id": line_id,
+        "translation": {
+            "nl": nl_str.strip(),
+            "en": en_str.strip(),
+        },
+        "nl_len": nl_l,
+        "en_len": en_l,
+    }
+    writer.write(str.encode(json.dumps(obj)))
+    writer.write("\n".encode("utf-8"))
+
+
+class TokenLength:
+    def __init__(self, tokenizer):
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            tokenizer, max_length=4096, truncation=False, use_fast=False
+        )
+
+    def __call__(self, text: str):
+        return len(self.tokenizer.encode(text, max_length=4096, truncation=False))
+
+
+class Counter:
+    def __init__(self, start=0):
+        self.count = start
+
+    def __call__(self):
+        self.count += 1
+        return self.count
+
+
+class Buffer:
+    def __init__(
+        self,
+        id: int,
+        emit_lines: bool,
+        max_length: int,
+        en_prefix="",
+    ):
+        self.id = id
+        self.emit_lines = emit_lines
+        self.max_length = max_length
+        self.en_prefix = en_prefix
+        self.counter = Counter()
+        self.nl_l = None
+        self.en_l = None
+        self.nl_buf = None
+        self.en_buf = None
+        self.cur_max_length = None
+        self.reset()
+
+    def set_cur_max_length(self):
+        """You can check the distribution with the following code:
+        %matplotlib notebook
+        import numpy as np
+        import matplotlib.pyplot as plt
+
+        plt.rcParams['figure.figsize'] = [9.5,6]
+        fig, ax = plt.subplots(1, 1)
+
+        r = np.random.beta(20,8,102000)
+        ax.hist(r, density=True, histtype='stepfilled', alpha=0.2, bins=200)
+        ax.legend(loc='best', frameon=False)
+        plt.show()
+        """
+        self.cur_max_length = int(self.max_length * np.random.beta(20, 8))
+
+    def reset(self):
+        self.nl_l = None
+        self.en_l = None
+        self.nl_buf = None
+        self.en_buf = None
+        self.set_cur_max_length()
+
+    def add_ok(self, nl_str, en_str, separator="\n"):
+        """If the new text fits within the max_length tokens, add it, else return False"""
+        nl_new = self.nl_buf + f"{separator}{nl_str}" if self.nl_buf else nl_str
+        en_new = self.en_buf + f"{separator}{en_str}" if self.en_buf else en_str
+        nl_new_l = token_length(nl_new)
+        en_new_l = token_length(en_new)
+        # Check if we can add it or if the result would be too long
+        if (
+            nl_new_l > self.cur_max_length
+            or token_length(self.en_prefix + en_new) > self.cur_max_length
+        ):
+            return False
+        else:
+            self.nl_buf = nl_new
+            self.en_buf = en_new
+            self.nl_l = nl_new_l
+            self.en_l = en_new_l
+            return True
+
+    def emit(self, row, separator):
+        nl_str = row.translation["nl"]
+        en_str = row.translation["en"]
+        nl_id = row.meta["sentenceIds"]["nl"]
+        en_id = row.meta["sentenceIds"]["en"]
+
+        # if one of the sentences ends on a . but the other doesn't, add a dot to the other
+        if nl_str.endswith(".") and not en_str.endswith("."):
+            en_str += "."
+        elif en_str.endswith(".") and not nl_str.endswith("."):
+            nl_str += "."
+        # Strip any leading "- " or "- " from the sentences
+        nl_str = nl_str.lstrip("- ")
+        en_str = en_str.lstrip("- ")
+
+        nl_len = token_length(nl_str)
+        en_len = token_length(en_str)
+        if self.emit_lines and nl_len <= COLLATE_LENGTH and en_len <= COLLATE_LENGTH:
+            emit(
+                line_id=f"{row.tconst}-nl{nl_id}-en{en_id}-l-",
+                nl_str=nl_str,
+                en_str=en_str,
+                nl_l=nl_len,
+                en_l=en_len,
+            )
+        if self.add_ok(nl_str.strip(), en_str.strip(), separator):
+            return
+
+        # If buf.add returns false, we've hit the maximum length boundary, so emit the current buffer, if it is not Empty
+        if self.nl_buf:
+            emit(
+                line_id=f"{row.tconst}-b{self.id}-{self.counter()}",
+                nl_str=self.nl_buf,
+                en_str=self.en_buf,
+                nl_l=self.nl_l,
+                en_l=self.en_l,
+            )
+            # After emit of the buffer, we reset the buffer
+            self.reset()
+
+        # Add the first line in this new buffer
+        result = self.add_ok(nl_str.strip(), en_str.strip())
+        if not result:
+            self.reset()
+
+
+if __name__ == "__main__":
+    token_length = TokenLength(tokenizer="yhavinga/ul2-base-dutch")
+    line_counter = Counter()
+
+    buffers = [
+        Buffer(
+            id=index, emit_lines=(index == 0), max_length=buf_max_length, en_prefix=""
+        )
+        for index, buf_max_length in enumerate([0.6 * 370, 370])
+    ]
+
+    df = pd.read_json("episode_opensubtitles.json.gz", lines=True)
+
+    with gzip.open("outfile", mode="wb") as writer:
+        for row in df.itertuples():
+            for buffer in buffers:
+                buffer.emit(row, separator="\n")

src/create_opensub_imdb_joined.py

@@ -0,0 +1,126 @@
+import duckdb as duckdb
+import pandas as pd
+import tabulate
+from datasets import load_dataset
+
+cursor = duckdb.connect()
+cursor.execute("PRAGMA threads=4")
+
+NROWS = 100000000
+NA_VALUES = "\\N"
+
+dataset = load_dataset("open_subtitles", lang1="en", lang2="nl", split="train")
+open_subtitles = dataset.data.table
+print(
+    tabulate.tabulate(
+        cursor.execute(f"SELECT * FROM open_subtitles LIMIT 5").fetchdf(),
+        headers="keys",
+        tablefmt="psql",
+    )
+)
+
+# title_akas = pd.read_csv('title.akas.tsv.gz', sep='\t', na_values=NA_VALUES, nrows=NROWS)
+# title_df = cursor.execute("SELECT * from title_akas limit 5").fetch_df()
+# print(tabulate.tabulate(title_df, headers="keys", tablefmt="psql"))
+
+title_basics = pd.read_csv(
+    "title.basics.tsv.gz", sep="\t", na_values=NA_VALUES, nrows=NROWS
+)
+basics_df = cursor.execute("SELECT * from title_basics limit 5").fetch_df()
+print(tabulate.tabulate(basics_df, headers="keys", tablefmt="psql"))
+
+title_episodes = pd.read_csv(
+    "title.episode.tsv.gz", sep="\t", na_values=NA_VALUES, nrows=NROWS
+)
+episodes_df = cursor.execute("SELECT * from title_episodes limit 5").fetch_df()
+print(tabulate.tabulate(episodes_df, headers="keys", tablefmt="psql"))
+
+title_ratings = pd.read_csv(
+    "title.ratings.tsv.gz", sep="\t", na_values=NA_VALUES, nrows=NROWS
+)
+ratings_df = cursor.execute("SELECT * from title_ratings limit 5").fetch_df()
+print(tabulate.tabulate(ratings_df, headers="keys", tablefmt="psql"))
+
+# # FIGURE OUT HOW WE CAN JOIN THE SUBTITLE DATASET WITH THE IMDB DATASET
+# count_join_subtitle_title_akas = cursor.execute(
+#     """
+#     SELECT COUNT(*) FROM open_subtitles JOIN title_akas ON 'tt' || open_subtitles.meta.imdbId = title_akas.titleId
+#     """
+# ).fetchall()
+# print(f"Count join subtitle title akas: {count_join_subtitle_title_akas}")
+#
+# count_join_subtitle_title_basics = cursor.execute(
+#     """
+#     SELECT COUNT(*) FROM open_subtitles JOIN title_basics ON 'tt' || open_subtitles.meta.imdbId = title_basics.tconst
+#     """
+# ).fetchdf()
+# print(f"Count join subtitle title basics: {count_join_subtitle_title_basics}")
+#
+# count_join_subtitle_title_episodes = cursor.execute(
+#     """
+#     SELECT COUNT(*) FROM open_subtitles JOIN title_episodes ON 'tt' || open_subtitles.meta.imdbId = title_episodes.tconst
+#     """
+# ).fetchdf()
+# print(f"Count join subtitle title episodes: {count_join_subtitle_title_episodes}")
+#
+# count_join_subtitle_title_episodes_parent = cursor.execute(
+#     """
+#     SELECT COUNT(*) FROM open_subtitles JOIN title_episodes ON 'tt' || open_subtitles.meta.imdbId = title_episodes.parentTconst
+#     """
+# ).fetchdf()
+# print(f"Count join subtitle title episodes parent: {count_join_subtitle_title_episodes_parent}")
+#
+# count_join_subtitle_title_ratings = cursor.execute(
+#     """
+#     SELECT COUNT(*) FROM open_subtitles JOIN title_ratings ON 'tt' || open_subtitles.meta.imdbId = title_ratings.tconst
+#     """
+# ).fetchdf()
+# print(f"Count join subtitle title ratings: {count_join_subtitle_title_ratings}")
+
+
+# join title_episode with its parent title_basics and title_ratings
+episode_detail = cursor.execute(
+    """
+    SELECT
+        open_subtitles.id,
+        open_subtitles.translation,
+        open_subtitles.meta,
+        title_basics.tconst,
+        title_basics.primaryTitle,
+        title_basics.startYear,
+        title_basics.endYear,
+        title_basics.genres,
+        title_basics.runtimeMinutes,
+        title_basics.titleType,
+        title_basics.isAdult,
+        title_ratings.tconst AS rating_tconst,
+        title_ratings.averageRating,
+        title_ratings.numVotes,
+        title_episodes.tconst as episode_tconst,
+        title_episodes.parentTconst,
+        title_episodes.seasonNumber,
+        title_episodes.episodeNumber
+    FROM
+        title_episodes
+    INNER JOIN
+        title_basics
+    ON
+        title_episodes.parentTconst = title_basics.tconst
+    INNER JOIN
+        title_ratings
+    ON
+        title_episodes.tconst = title_ratings.tconst
+    INNER JOIN
+        open_subtitles
+    ON
+        title_episodes.tconst = 'tt' || open_subtitles.meta.imdbId
+    WHERE isAdult == 0
+    and averageRating > 8.0
+    and numVotes > 1000
+    ORDER BY startYear, episode_tconst, seasonNumber, episodeNumber, meta.sentenceIds.en
+    """
+).fetch_df()
+print(tabulate.tabulate(episode_detail[:5], headers="keys", tablefmt="psql"))
+
+# write episode_detail to json file
+episode_detail.to_json("episode_opensubtitles.json", orient="records", lines=True)

src/episode_opensubtitles.json.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:612bc5d454dbbe15fd03200be5a174cd22a02fae628b7f7391db874a1786b186
+size 139127032

train.jsonl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aceec2f2def4ce2ffedea50b1899116adbf16c49cf565c049908a4b523bd5a4f
+size 155466680