Add files using upload-large-folder tool

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,97 @@
+# Chat Data Pipeline
+
+This repository helps to clean, filter and deduplicate conversation datasets.
+
+Open Source Community rules the world, so please contribute: open Pull Request or create an Issue.
+
+Star this repository:
+
+[![GitHub stars](https://img.shields.io/github/stars/AlekseyKorshuk/chat-data-pipeline?style=social)](https://github.com/AlekseyKorshuk/chat-data-pipeline)
+
+## Quick Start
+
+Clone and install dependencies:
+
+```shell
+git clone https://github.com/AlekseyKorshuk/chat-data-pipeline
+cd chat-data-pipeline
+pip install -r requirements.txt
+```
+
+We will prepare very small dataset of instructions:
+
+```shell
+python3 main.py --config_path ./experiments/tiny-example.yaml
+```
+
+You can take a look at the YAML file to discover the structure of the config.
+
+Initial dataset has the following structure of one sample:
+
+```json
+{
+  "conversation": [
+    {
+      "content": "Explain the main differences between an alligator and a crocodile.",
+      "do_train": false,
+      "role": "User"
+    },
+    {
+      "content": "Alligators and crocodiles belong to the same order, Crocodilia, but they have several differences. 1) Shape of the snout: Alligators have a U-shaped, wider snout, while crocodiles have a more pointed, V-shaped snout. 2) Teeth placement: In an alligator, lower teeth are mostly hidden when its mouth is closed, while in a crocodile, the fourth lower tooth is visible even when the mouth is closed. 3) Habitat: Alligators are mostly found in freshwater habitats such as swamps and rivers, while crocodiles can be found in both freshwater and saltwater habitats. 4) Distribution: Alligators are mainly found in the southeastern United States and parts of China, whereas crocodiles have a more widespread distribution across Africa, Asia, the Americas, and Australia.",
+      "do_train": true,
+      "role": "Assistant"
+    }
+  ]
+}
+```
+
+This example could have more conversation turns: User, Assistant, User, Assistant...
+
+As well role can be "System" at the very first item in the list.
+
+# Custom Setup
+
+In general, you can use this for any dataset that has a string column. Here is an example usage:
+
+```python
+from datasets import load_dataset
+
+from chat_data_pipeline import utils
+from chat_data_pipeline.preprocessor import DataPreprocessor
+from chat_data_pipeline import cleaners as cln
+from chat_data_pipeline import filters as ftr
+
+dataset = load_dataset("AlekseyKorshuk/tiny-imdb", split="train")
+
+deduplication_config = {
+    'do_deduplication': True,
+    'minhash_config': {
+        'ngram_size': 5,
+        'num_perm': 256,
+        'threshold': 0.7,
+        'min_ngram_size': 5
+    }
+}
+
+cleaners = [cln.fix_utf8_encoding, cln.normalize_punctuation, cln.remove_empty_lines]
+filters = [
+    utils.custom_partial(ftr.check_word_number,
+                         min_word_threshold=0,
+                         max_word_threshold=10000),
+]
+
+preprocessor = DataPreprocessor(
+    dataset=dataset,
+    column_name="text",
+    cleaners=cleaners,
+    filters=filters,
+    deduplication_config=deduplication_config,
+    verbose=False,
+)
+preprocessed_dataset = preprocessor.run()
+```
+
+## Acknowledgment
+
+This is a friendly fork of Squeakily by CarperAI, but this repository aims at conversation data, uses pandas to
+speed up the pipeline and latest near deduplication. 

chat_data_pipeline/cleaners.py

@@ -0,0 +1,79 @@
+import re
+import ftfy
+
+
+def fix_utf8_encoding(text):
+    if text is None:
+        return ""
+    return ftfy.fix_text(text)
+
+
+# Adapted from:
+# https://github.com/bigscience-workshop/data-preparation/blob/main/preprocessing/training/01b_oscar_cleaning_and_filtering/filtering.py#L95
+whitespace = {" ", " ", " ", " ", " ", "　", " ", " ", " ", " ", "", "„"}
+
+
+def normalize_whitespace(text):
+    chars = [char if char not in whitespace else " " for char in text]
+    text = "".join(chars)
+    return text
+
+
+unicode_punctuation = {
+    "，": ",",
+    "。": ".",
+    "、": ",",
+    "„": '"',
+    "”": '"',
+    "“": '"',
+    "«": '"',
+    "»": '"',
+    "１": '"',
+    "」": '"',
+    "「": '"',
+    "《": '"',
+    "》": '"',
+    "´": "'",
+    "∶": ":",
+    "：": ":",
+    "？": "?",
+    "！": "!",
+    "（": "(",
+    "）": ")",
+    "；": ";",
+    "–": "-",
+    "—": " - ",
+    "．": ". ",
+    "～": "~",
+    "’": "'",
+    "…": "...",
+    "━": "-",
+    "〈": "<",
+    "〉": ">",
+    "【": "[",
+    "】": "]",
+    "％": "%",
+    "►": "-",
+}
+
+
+def normalize_punctuation(text):
+    chars = [unicode_punctuation.get(char, char) for char in text]
+    text = "".join(chars)
+    return text
+
+
+def remove_empty_lines(text):
+    lines = text.splitlines()
+    func = lambda x: not re.match(r'^\s*$', x)
+    filtered = filter(func, lines)
+    text = "\n".join(filtered)
+    if text is None or isinstance(text, str):
+        text = ""
+    return text
+
+
+def clean_new_lines(text):
+    text = text.strip()
+    text = text.replace("\n", "")
+    return text

chat_data_pipeline/filters.py

@@ -0,0 +1,289 @@
+import string
+
+from chat_data_pipeline import utils
+
+
+def check_word_number(
+        document,
+        min_word_threshold=5,
+        max_word_threshold=512,
+        dry_run=False,
+):
+    words = utils.get_words(document)
+    if dry_run:
+        return len(words)
+    return min_word_threshold <= len(words) <= max_word_threshold
+
+
+def check_perplexity(
+        document,
+        kenlm_model,
+        min_perplexity_threshold=300,
+        max_perplexity_threshold=3_000,
+        dry_run=False,
+):
+    perplexity = kenlm_model.get_perplexity(document)
+    if dry_run:
+        return perplexity
+    return min_perplexity_threshold <= perplexity <= max_perplexity_threshold
+
+
+nsfw_words = ['2g1c', '2 girls 1 cup', 'acrotomophilia', 'alabama hot pocket', 'alaskan pipeline', 'anal', 'anilingus',
+              'anus', 'apeshit', 'arsehole', 'ass', 'asshole', 'assmunch', 'auto erotic', 'autoerotic', 'babeland',
+              'baby batter', 'baby juice', 'ball gag', 'ball gravy', 'ball kicking', 'ball licking', 'ball sack',
+              'ball sucking', 'bangbros', 'bangbus', 'bareback', 'barely legal', 'barenaked', 'bastard', 'bastardo',
+              'bastinado', 'bbw', 'bdsm', 'beaner', 'beaners', 'beaver cleaver', 'beaver lips', 'beastiality',
+              'bestiality', 'big black', 'big breasts', 'big knockers', 'big tits', 'bimbos', 'birdlock', 'bitch',
+              'bitches', 'black cock', 'blonde action', 'blonde on blonde action', 'blowjob', 'blow job',
+              'blow your load', 'blue waffle', 'blumpkin', 'bollocks', 'bondage', 'boner', 'boob', 'boobs',
+              'booty call', 'brown showers', 'brunette action', 'bukkake', 'bulldyke', 'bullet vibe', 'bullshit',
+              'bung hole', 'bunghole', 'busty', 'butt', 'buttcheeks', 'butthole', 'camel toe', 'camgirl', 'camslut',
+              'camwhore', 'carpet muncher', 'carpetmuncher', 'chocolate rosebuds', 'cialis', 'circlejerk',
+              'cleveland steamer', 'clit', 'clitoris', 'clover clamps', 'clusterfuck', 'cock', 'cocks', 'coprolagnia',
+              'coprophilia', 'cornhole', 'coon', 'coons', 'creampie', 'cum', 'cumming', 'cumshot', 'cumshots',
+              'cunnilingus', 'cunt', 'darkie', 'date rape', 'daterape', 'deep throat', 'deepthroat', 'dendrophilia',
+              'dick', 'dildo', 'dingleberry', 'dingleberries', 'dirty pillows', 'dirty sanchez', 'doggie style',
+              'doggiestyle', 'doggy style', 'doggystyle', 'dog style', 'dolcett', 'domination', 'dominatrix', 'dommes',
+              'donkey punch', 'double dong', 'double penetration', 'dp action', 'dry hump', 'dvda', 'eat my ass',
+              'ecchi', 'ejaculation', 'erotic', 'erotism', 'escort', 'eunuch', 'fag', 'faggot', 'fecal', 'felch',
+              'fellatio', 'feltch', 'female squirting', 'femdom', 'figging', 'fingerbang', 'fingering', 'fisting',
+              'foot fetish', 'footjob', 'frotting', 'fuck', 'fuck buttons', 'fuckin', 'fucking', 'fucktards',
+              'fudge packer', 'fudgepacker', 'futanari', 'gangbang', 'gang bang', 'gay sex', 'genitals', 'giant cock',
+              'girl on', 'girl on top', 'girls gone wild', 'goatcx', 'goatse', 'god damn', 'gokkun', 'golden shower',
+              'goodpoop', 'goo girl', 'goregasm', 'grope', 'group sex', 'g-spot', 'guro', 'hand job', 'handjob',
+              'hard core', 'hardcore', 'hentai', 'homoerotic', 'honkey', 'hooker', 'horny', 'hot carl', 'hot chick',
+              'how to kill', 'how to murder', 'huge fat', 'humping', 'incest', 'intercourse', 'jack off', 'jail bait',
+              'jailbait', 'jelly donut', 'jerk off', 'jigaboo', 'jiggaboo', 'jiggerboo', 'jizz', 'juggs', 'kike',
+              'kinbaku', 'kinkster', 'kinky', 'knobbing', 'leather restraint', 'leather straight jacket', 'lemon party',
+              'livesex', 'lolita', 'lovemaking', 'make me come', 'male squirting', 'masturbate', 'masturbating',
+              'masturbation', 'menage a trois', 'milf', 'missionary position', 'mong', 'motherfucker', 'mound of venus',
+              'mr hands', 'muff diver', 'muffdiving', 'nambla', 'nawashi', 'negro', 'neonazi', 'nigga', 'nigger',
+              'nig nog', 'nimphomania', 'nipple', 'nipples', 'nsfw', 'nsfw images', 'nude', 'nudity', 'nutten',
+              'nympho', 'nymphomania', 'octopussy', 'omorashi', 'one cup two girls', 'one guy one jar', 'orgasm',
+              'orgy', 'paedophile', 'paki', 'panties', 'panty', 'pedobear', 'pedophile', 'pegging', 'penis',
+              'phone sex', 'piece of shit', 'pikey', 'pissing', 'piss pig', 'pisspig', 'playboy', 'pleasure chest',
+              'pole smoker', 'ponyplay', 'poof', 'poon', 'poontang', 'punany', 'poop chute', 'poopchute', 'porn',
+              'porno', 'pornography', 'prince albert piercing', 'pthc', 'pubes', 'pussy', 'queaf', 'queef', 'quim',
+              'raghead', 'raging boner', 'rape', 'raping', 'rapist', 'rectum', 'reverse cowgirl', 'rimjob', 'rimming',
+              'rosy palm', 'rosy palm and her 5 sisters', 'rusty trombone', 'sadism', 'santorum', 'scat', 'schlong',
+              'scissoring', 'semen', 'sex', 'sexcam', 'sexo', 'sexy', 'sexual', 'sexually', 'sexuality',
+              'shaved beaver', 'shaved pussy', 'shemale', 'shibari', 'shit', 'shitblimp', 'shitty', 'shota',
+              'shrimping', 'skeet', 'slanteye', 'slut', 's&m', 'smut', 'snatch', 'snowballing', 'sodomize', 'sodomy',
+              'spastic', 'spic', 'splooge', 'splooge moose', 'spooge', 'spread legs', 'spunk', 'strap on', 'strapon',
+              'strappado', 'strip club', 'style doggy', 'suck', 'sucks', 'suicide girls', 'sultry women', 'swastika',
+              'swinger', 'tainted love', 'taste my', 'tea bagging', 'threesome', 'throating', 'thumbzilla', 'tied up',
+              'tight white', 'tit', 'tits', 'titties', 'titty', 'tongue in a', 'topless', 'tosser', 'towelhead',
+              'tranny', 'tribadism', 'tub girl', 'tubgirl', 'tushy', 'twat', 'twink', 'twinkie', 'two girls one cup',
+              'undressing', 'upskirt', 'urethra play', 'urophilia', 'vagina', 'venus mound', 'viagra', 'vibrator',
+              'violet wand', 'vorarephilia', 'voyeur', 'voyeurweb', 'voyuer', 'vulva', 'wank', 'wetback', 'wet dream',
+              'white power', 'whore', 'worldsex', 'wrapping men', 'wrinkled starfish', 'xx', 'xxx', 'yaoi',
+              'yellow showers', 'yiffy', 'zoophilia', '🖕']
+
+
+def check_nsfw_words(
+        document,
+        flagged_words_threshold=0.025,
+        dry_run=False,
+):
+    document = str(document.lower())
+    num_words = len(utils.get_words(document))
+    flagged_words_ratio = 0
+    if num_words > 0:
+        num_bad_words = sum(
+            [document.count(bad_word) for bad_word in nsfw_words]
+        )
+        flagged_words_ratio = num_bad_words / num_words
+
+    if dry_run:
+        return flagged_words_ratio
+    return flagged_words_ratio <= flagged_words_threshold
+
+
+def check_lowercase_ratio(
+        document,
+        lowercase_threshold=0.75,
+        dry_run=False,
+):
+    ascii_lowercase = string.ascii_lowercase
+    count = lambda l1, l2: len(list(filter(lambda c: c in l2, l1)))
+    letter_count = count(document, ascii_lowercase)
+    lowercase_ratio = letter_count / len(document) if len(document) else 0
+    if dry_run:
+        return lowercase_ratio
+    return lowercase_ratio >= lowercase_threshold
+
+
+def check_char_repetition(
+        document,
+        char_repetition_len=10,
+        char_repetition_threshold=0.2,
+        dry_run=False,
+):
+    char_rep_ratio = utils.get_char_repetition_ratio(
+        document, char_repetition_len
+    )
+    if dry_run:
+        return char_rep_ratio
+    else:
+        return char_rep_ratio <= char_repetition_threshold
+
+
+def check_truncation(
+        document,
+        splitter_token="<|truncation_splitter|>",
+        dry_run=False,
+):
+    model_response, edited_response = document.split(splitter_token)
+    is_truncation = edited_response not in model_response
+    if dry_run:
+        is_truncation = int(is_truncation)
+    return is_truncation
+
+
+punctuations = {".", "!", "?", "*", '"', "”", "~", "…", "'", "]", ")", "`", ";"}
+
+
+def check_completion(
+        document,
+        dry_run=False,
+):
+    document = str(document).strip()
+    last_char = None if len(document) == 0 else document[-1]
+
+    is_completed = last_char in punctuations
+    if dry_run:
+        is_completed = int(is_completed)
+    return is_completed
+
+
+def check_gender(
+        document,
+        splitter_token="<|gender_splitter|>",
+        dry_run=False,
+):
+    response, edited_response = document.split(splitter_token)
+    gendered_words = ['he', 'she', 'him', 'her', 'girl', 'boy']
+    response_words = response.lower().split()
+    edited_words = edited_response.lower().split()
+    min_length = min(len(response_words), len(edited_words))
+    for i in range(min_length):
+        is_response_word_gender = response_words[i] in gendered_words
+        is_edited_word_gender = edited_words[i] in gendered_words
+        if is_response_word_gender and is_edited_word_gender and \
+                response_words[i] != edited_words[i]:
+            return True
+    return False
+
+
+def check_empty(
+        document,
+        dry_run=False,
+):
+    document = document.replace("...", "")
+    document = document.replace("…", "")
+    document = document.strip()
+    return len(document) != 0
+
+
+unwanted_words = [
+    "prioritize human safety"
+    "ethical principles"
+    "harmful to human beings"
+    "September 2021"
+    "as a language model",
+    "ethical guidelines",
+    "as an AI language model",
+    "my guidelines",
+    "As an AI",
+    "prioritize user safety",
+    "adhere to ethical guidelines",
+    "harmful consequences",
+    "potentially harmful",
+    "dangerous activities",
+    "promote safety",
+    "well-being of all users",
+    "responsible information sharing",
+    "jeopardize the safety",
+    "illegal actions or intentions",
+    "undermine the stability",
+    "promote the well-being",
+    "illegal activities or actions",
+    "adherence to the law",
+    "potentially be harmful",
+    "illegal substances or activities",
+    "committed to promoting",
+    "safe information",
+    "lawful information",
+    "cannot provide guidance",
+    "cannot provide information",
+    "unable to offer assistance",
+    "cannot engage in discussions",
+    "programming prohibits",
+    "follow ethical guidelines",
+    "ensure the safety",
+    "involves an illegal subject",
+    "prioritize safety",
+    "illegal subject",
+    "prioritize user well-being",
+    "cannot support or promote",
+    "activities that could harm",
+    "pose a risk to others",
+    "against my programming",
+    "activities that could undermine",
+    "potentially dangerous",
+    "not within the scope",
+    "designed to prioritize safety",
+    "not able to provide",
+    "maintain user safety",
+    "adhere to safety guidelines",
+    "dangerous or harmful",
+    "cannot provide any information",
+    "focus on promoting safety",
+]
+harsh_unwanted_words = [
+    "i'm sorry",
+    "i am sorry",
+    "OpenAI",
+    "ChatGPT",
+    "Assistant",
+    "don't know",
+    "do not know",
+    "can not feel",
+    "can't feel",
+    "don't understand",
+    "do not understand",
+    "<noinput>",
+    "sorry",
+    "AI",
+    "language model",
+    "LLM",
+    "Artificial intelligence"
+    "assist",
+    "harm",
+    "help",
+    "welcome",
+]
+unwanted_words = [unwanted_word.lower().strip() for unwanted_word in unwanted_words]
+harsh_unwanted_words = [unwanted_word.lower().strip() for unwanted_word in unwanted_words + harsh_unwanted_words]
+
+
+def check_ethics(
+        document,
+        dry_run=False,
+):
+    document = str(document.lower())
+    for unwanted_string in unwanted_words:
+        if unwanted_string in document:
+            return False
+    return True
+
+
+def check_ethics_harsh(
+        document,
+        dry_run=False,
+):
+    document = str(document.lower())
+    for unwanted_string in harsh_unwanted_words:
+        if unwanted_string in document:
+            return False
+    return True

chat_data_pipeline/kenlm_model.py

@@ -0,0 +1,200 @@
+"""
+Adapted from KenLM repository: https://huggingface.co/edugp/kenlm
+"""
+
+import os
+import re
+import unicodedata
+
+from huggingface_hub import cached_download, hf_hub_url
+import sentencepiece
+import kenlm
+from requests.exceptions import HTTPError
+from typing import Dict
+
+KENLM_MODEL_REPO = "edugp/kenlm"
+
+
+class SentencePiece:
+    def __init__(
+            self,
+            model: str,
+    ):
+        super().__init__()
+        self.sp = sentencepiece.SentencePieceProcessor()
+        self.sp.load(str(model))
+
+    def do(self, text: dict) -> dict:
+        tokenized = self.sp.encode_as_pieces(text)
+        return " ".join(tokenized)
+
+
+class KenlmModel:
+    digit_re: re.Pattern = re.compile(r"\d")
+    unicode_punct: Dict[str, str] = {
+        "，": ",",
+        "。": ".",
+        "、": ",",
+        "„": '"',
+        "”": '"',
+        "“": '"',
+        "«": '"',
+        "»": '"',
+        "１": '"',
+        "」": '"',
+        "「": '"',
+        "《": '"',
+        "》": '"',
+        "´": "'",
+        "∶": ":",
+        "：": ":",
+        "？": "?",
+        "！": "!",
+        "（": "(",
+        "）": ")",
+        "；": ";",
+        "–": "-",
+        "—": " - ",
+        "．": ". ",
+        "～": "~",
+        "’": "'",
+        "…": "...",
+        "━": "-",
+        "〈": "<",
+        "〉": ">",
+        "【": "[",
+        "】": "]",
+        "％": "%",
+        "►": "-",
+    }
+    unicode_punct_re = re.compile(f"[{''.join(unicode_punct.keys())}]")
+    non_printing_chars_re = re.compile(
+        f"[{''.join(map(chr, list(range(0, 32)) + list(range(127, 160))))}]"
+    )
+    kenlm_model_dir = None
+    sentence_piece_model_dir = None
+
+    def __init__(
+            self,
+            model_dataset: str,
+            language: str,
+            lower_case: bool = False,
+            remove_accents: bool = False,
+            normalize_numbers: bool = True,
+            punctuation: int = 1,
+    ):
+        self.download_kenlm_model(model_dataset, language)
+        try:
+            self.model = kenlm.Model(self.kenlm_model_dir)
+            self.tokenizer = SentencePiece(self.sentence_piece_model_dir)
+        except OSError:
+            os.remove(self.kenlm_model_dir)
+            if os.path.exists(self.sentence_piece_model_dir):
+                os.remove(self.sentence_piece_model_dir)
+            raise OSError(
+                "File was corrupt and should have been removed. Please, retry."
+            )
+        self.accent = remove_accents
+        self.case = lower_case
+        self.numbers = normalize_numbers
+        self.punct = punctuation
+
+    @classmethod
+    def from_pretrained(
+            cls,
+            *,
+            model_dataset: str,
+            language: str,
+            lower_case: bool,
+            remove_accents: bool,
+            normalize_numbers: bool,
+            punctuation: int,
+    ):
+        return cls(
+            model_dataset,
+            language,
+            lower_case,
+            remove_accents,
+            normalize_numbers,
+            punctuation,
+        )
+
+    def pp(self, log_score, length):
+        return 10.0 ** (-log_score / length)
+
+    def get_perplexity(self, doc: str, normalize_cc_net: bool = True):
+        if normalize_cc_net:
+            doc = self.normalize(
+                doc,
+                accent=self.accent,
+                case=self.case,
+                numbers=self.numbers,
+                punct=self.punct,
+            )
+        # Tokenize (after normalizing): See https://github.com/facebookresearch/cc_net/blob/bda555bd1cf1ee2e0b925363e62a61cd46c8b60d/cc_net/mine.py#L352 for full pipeline
+        doc = self.tokenizer.do(doc)
+        doc_log_score, doc_length = 0, 0
+        for line in doc.split("\n"):
+            log_score = self.model.score(line)
+            length = len(line.split()) + 1
+            doc_log_score += log_score
+            doc_length += length
+        return round(self.pp(doc_log_score, doc_length), 1)
+
+    def normalize(
+            self,
+            line: str,
+            accent: bool = True,
+            case: bool = True,
+            numbers: bool = True,
+            punct: int = 1,
+    ) -> str:
+        line = line.strip()
+        if not line:
+            return line
+        if case:
+            line = line.lower()
+        if accent:
+            line = self.strip_accents(line)
+        if numbers:
+            line = self.digit_re.sub("0", line)
+        if punct == 1:
+            line = self.replace_unicode_punct(line)
+        elif punct == 2:
+            line = self.remove_unicode_punct(line)
+        line = self.remove_non_printing_char(line)
+        return line
+
+    def strip_accents(self, line: str) -> str:
+        """Strips accents from a piece of text."""
+        nfd = unicodedata.normalize("NFD", line)
+        output = [c for c in nfd if unicodedata.category(c) != "Mn"]
+        if len(output) == line:
+            return line
+        return "".join(output)
+
+    def replace_unicode_punct(self, text: str) -> str:
+        return "".join(self.unicode_punct.get(c, c) for c in text)
+
+    def remove_unicode_punct(self, text: str) -> str:
+        """More aggressive version of replace_unicode_punct but also faster."""
+        return self.unicode_punct_re.sub("", text)
+
+    def remove_non_printing_char(self, text: str) -> str:
+        return self.non_printing_chars_re.sub("", text)
+
+    def download_kenlm_model(self, model_dataset: str, language: str):
+        try:
+            kenlm_model_url = hf_hub_url(
+                KENLM_MODEL_REPO, filename=f"{model_dataset}/{language}.arpa.trie.bin"
+            )
+            self.kenlm_model_dir = cached_download(kenlm_model_url)
+        except HTTPError:
+            kenlm_model_url = hf_hub_url(
+                KENLM_MODEL_REPO, filename=f"{model_dataset}/{language}.arpa.bin"
+            )
+            self.kenlm_model_dir = cached_download(kenlm_model_url)
+        sentence_piece_model_url = hf_hub_url(
+            KENLM_MODEL_REPO, filename=f"{model_dataset}/{language}.sp.model"
+        )
+        self.sentence_piece_model_dir = cached_download(sentence_piece_model_url)

chat_data_pipeline/minhash_deduplication.py

@@ -0,0 +1,319 @@
+"""
+Adapted from BigCode project: https://github.com/bigcode-project/bigcode-dataset/tree/main/near_deduplication
+"""
+
+from __future__ import annotations
+
+import gc
+import hashlib
+import multiprocessing as mp
+import os
+import random
+import re
+import struct
+import time
+from collections import defaultdict
+from itertools import tee
+from typing import Any, Dict, Iterable, List, Tuple
+
+import numpy as np
+from scipy.integrate import quad as integrate
+from tqdm import tqdm
+
+from chat_data_pipeline.pipeline import logger
+
+SEED = 42
+NON_ALPHA = re.compile("[^A-Za-z_0-9]")
+RNG = np.random.RandomState(SEED)
+MAX_HASH = np.uint64((1 << 32) - 1)
+MERSENNE_PRIME = np.uint64((1 << 61) - 1)
+
+
+def ngrams(sequence: List[str], n: int, min_ngram_size: int) -> Iterable:
+    """
+    Directly taken from nltk package to avoid dependency.
+
+    Parameters
+    ----------
+    sequence : list
+        The sequence of items to be n-grammed.
+    n : int
+        The order of the n-grams to be extracted.
+    min_ngram_size : int
+        The minimum size of n-grams.
+
+    Returns
+    -------
+    Iterable
+        The n-grams generated from the sequence.
+    """
+    if len(sequence) < min_ngram_size:
+        return []
+    iterables = tee(sequence, n)
+    for i, sub_iterable in enumerate(iterables):
+        for _ in range(i):
+            next(sub_iterable, None)
+    return zip(*iterables)
+
+
+def sha1_hash32(data):
+    """
+    Directly taken from datasketch package to avoid dependency.
+
+    Parameters
+    ----------
+    data : bytes
+
+    Returns
+    -------
+    int
+    """
+    return struct.unpack("<I", hashlib.sha1(data).digest()[:4])[0]
+
+
+def embed_func(
+        content: str,
+        idx: int,
+        *,
+        num_perm: int,
+        ngram_size: int,
+        hashranges: List[Tuple[int, int]],
+        permutations: np.ndarray,
+        min_ngram_size: int = 5,
+) -> Dict[str, Any]:
+    """
+    Combined with some datasketch code to better parallelize computation.
+
+    Parameters
+    ----------
+    content : str
+        The content to be embedded.
+    idx : int
+        The index of the content.
+    num_perm : int
+        The number of permutations.
+    ngram_size : int
+        The size of n-grams.
+    hashranges : List[Tuple[int, int]]
+        The ranges of hash values.
+    permutations : np.ndarray
+        The permutations for the minhash.
+    min_ngram_size : int
+        The minimum size of n-grams.
+
+    Returns
+    -------
+    Dict[str, Any]
+        The hash values in each range and the index.
+    """
+    hashvalues = np.ones(num_perm, dtype=np.uint64) * MAX_HASH
+    tokens = {" ".join(t) for t in ngrams(NON_ALPHA.split(content), ngram_size, min_ngram_size)}
+    hv = np.array([sha1_hash32(token.encode("utf-8")) for token in tokens], dtype=np.uint64)  # noqa: E501
+    a, b = permutations
+    phv = np.bitwise_and(((hv * np.tile(a, (len(hv), 1)).T).T + b) % MERSENNE_PRIME, MAX_HASH)  # noqa: E501
+    hashvalues = np.vstack([phv, hashvalues]).min(axis=0)
+    Hs = [bytes(hashvalues[start:end].byteswap().data) for start, end in hashranges]
+    return {"__signatures__": Hs, "__id__": idx}
+
+
+def optimal_param(
+        threshold: float,
+        num_perm: int,
+        false_positive_weight: float = 0.5,
+        false_negative_weight: float = 0.5,
+):
+    """
+    Compute the optimal `MinHashLSH` parameter that minimizes the weighted sum
+    of probabilities of false positive and false negative, taken from datasketch.
+
+    Parameters
+    ----------
+    threshold : float
+        The threshold for similarity.
+    num_perm : int
+        The number of permutations.
+    false_positive_weight : float
+        The weight of false positive.
+    false_negative_weight : float
+        The weight of false negative.
+
+    Returns
+    -------
+    Tuple[int, int]
+        The optimal `b` and `r` parameters.
+        The number of bands, and the number of rows per band respectively.
+    """
+
+    def false_positive_probability(threshold: float, b: int, r: int):
+        """Source: `datasketch.lsh`"""
+
+        def proba(s):
+            return 1 - (1 - s ** float(r)) ** float(b)
+
+        a, _ = integrate(proba, 0.0, threshold)
+        return a
+
+    def false_negative_probability(threshold: float, b: int, r: int):
+        """Source: `datasketch.lsh`"""
+
+        def proba(s):
+            return 1 - (1 - (1 - s ** float(r)) ** float(b))
+
+        a, _ = integrate(proba, threshold, 1.0)
+        return a
+
+    min_error = float("inf")
+    opt = (0, 0)
+    for b in range(1, num_perm + 1):
+        max_r = int(num_perm / b)
+        for r in range(1, max_r + 1):
+            fp = false_positive_probability(threshold, b, r)
+            fn = false_negative_probability(threshold, b, r)
+            error = fp * false_positive_weight + fn * false_negative_weight
+            if error < min_error:
+                min_error = error
+                opt = (b, r)
+    return opt
+
+
+class UnionFind:
+    def __init__(self):
+        self.parent: Dict[int, int] = {}
+
+    def find(self, x):
+        if x not in self.parent:
+            self.parent[x] = x
+        if self.parent[x] != x:
+            self.parent[x] = self.find(self.parent[x])
+        return self.parent[x]
+
+    def union(self, x, y):
+        px = self.find(x)
+        py = self.find(y)
+        self.parent[px] = self.parent[py] = min(px, py)
+
+
+def prepare_dataset(dataset):
+    def map_func(example):
+        text = ""
+        for message in example["conversation"]:
+            if message["do_train"]:
+                text += message["content"] + "\n\n"
+        return {
+            "text": text.strip()
+        }
+
+    dedup_ready_dataset = dataset.map(
+        map_func,
+        num_proc=os.cpu_count(),
+        desc="Preparing..."
+    )
+    return dedup_ready_dataset
+
+
+def deduplicate(
+        dataset,  # noqa: E501
+        column="text",
+        ngram_size=5,
+        num_perm=256,
+        threshold=0.7,
+        min_ngram_size=5,
+):
+    mp.set_start_method("fork", force=True)
+    uf = UnionFind()
+
+    time_measures = {}
+    start_time = time.time()
+
+    B, R = optimal_param(threshold, num_perm)
+    HASH_RANGES = [(i * R, (i + 1) * R) for i in range(B)]
+    HASH_TABLES = [defaultdict(set) for _ in range(B)]
+
+    time_measures["load_dataset"] = time.time()
+    time_measures["load_dataset"] = time.time() - time_measures["load_dataset"]
+    DATA_SIZE = len(dataset)
+    PERMUTATIONS = np.array(
+        [
+            (
+                RNG.randint(1, MERSENNE_PRIME, dtype=np.uint64),
+                RNG.randint(0, MERSENNE_PRIME, dtype=np.uint64),
+            )
+            for _ in range(num_perm)
+        ],
+        dtype=np.uint64,
+    ).T
+
+    time_measures["minhash"] = time.time()
+    embedded = dataset.map(
+        function=embed_func,
+        fn_kwargs={
+            "num_perm": num_perm,
+            "hashranges": HASH_RANGES,
+            "ngram_size": ngram_size,
+            "permutations": PERMUTATIONS,
+            "min_ngram_size": min_ngram_size,
+        },
+        input_columns=[column],
+        remove_columns=dataset.column_names,
+        num_proc=os.cpu_count(),
+        with_indices=True,
+        desc="Fingerprinting...",
+    )
+    time_measures["minhash"] = time.time() - time_measures["minhash"]
+
+    time_measures["clustering"] = time.time()
+    batch_size: int = 10000
+    for i in tqdm(
+            range(0, len(embedded), batch_size), dynamic_ncols=True, desc="Iterating MinHashes..."  # noqa: E501
+    ):
+        batch = embedded[i: i + batch_size]
+        for key, Hs in zip(batch["__id__"], batch["__signatures__"]):
+            for H, hashtable in zip(Hs, HASH_TABLES):
+                hashtable[H].add(key)
+    for table in tqdm(HASH_TABLES, dynamic_ncols=True, desc="Clustering..."):
+        for cluster in table.values():
+            if len(cluster) <= 1:
+                continue
+            idx = min(cluster)
+            for x in cluster:
+                uf.union(x, idx)
+    time_measures["clustering"] = time.time() - time_measures["clustering"]
+
+    time_measures["filtering"] = time.time()
+    gc.freeze()
+    gc.disable()
+    dataset = dataset.map(
+        function=lambda _, idx: {"__cluster__": uf.find(idx)},
+        with_indices=True,
+        num_proc=os.cpu_count(),
+        new_fingerprint=str(random.getrandbits(128)),
+        desc="Finding clusters...",
+    )
+    gc.enable()
+    gc.collect()
+    # This is where the deduplication happens
+    # Since there is no easy groupby in datasets
+    # I will use this simple filter for now
+    final_data = dataset.filter(
+        function=lambda record, idx: record["__cluster__"] == idx,
+        with_indices=True,
+        num_proc=os.cpu_count(),
+        desc="Filtering clusters...",
+    )
+    time_measures["filtering"] = time.time() - time_measures["filtering"]
+
+    FINAL_DATA_SIZE = len(final_data)
+    DUP_SIZE = DATA_SIZE - FINAL_DATA_SIZE
+    PAD = 32
+
+    for key, value in time_measures.items():
+        logger.info(f"{key:<{PAD}}: {value:.2f} seconds")
+    logger.info(f"{'Data Number (before)':<{PAD}}: {DATA_SIZE}")
+    logger.info(
+        f"{'Data Number (after)':<{PAD}}: {FINAL_DATA_SIZE} ({FINAL_DATA_SIZE / DATA_SIZE:.2%})"  # noqa: E501
+    )
+    logger.info(f"{'Duplicate Number':<{PAD}}: {DUP_SIZE} ({DUP_SIZE / DATA_SIZE:.2%})")  # noqa: E501
+    logger.info(f"{'Total Time':<{PAD}}: {time.time() - start_time:.2f} seconds")
+    logger.info("🤗 Happy Deduplicating 🤗")
+
+    return final_data

chat_data_pipeline/pipeline.py

@@ -0,0 +1,75 @@
+import logging
+
+import numpy as np
+from datasets import Dataset, concatenate_datasets
+from rich.logging import RichHandler
+import tqdm
+
+tqdm.tqdm.pandas()
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(RichHandler(rich_tracebacks=True))
+# Turn off logging for datasets
+logging.getLogger("datasets").setLevel(logging.ERROR)
+
+
+class Pipeline:
+    def __init__(self, datasources):
+        self.datasources = datasources
+
+    def run(self, dry_run=False):
+        for i in range(len(self.datasources)):
+            self.datasources[i]["dataset"] = self.datasources[i]["dataset"].to_pandas()
+
+            column_name = self.datasources[i]["columns"][0]
+            logger.info(f"Running datasource: {self.datasources[i]['name']}")
+
+            for cleaner_func in self.datasources[i]["cleaners"]:
+                self.datasources[i]["dataset"] = apply_cleaner(
+                    self.datasources[i]["dataset"],
+                    column_name,
+                    cleaner_func
+                )
+
+            for filter_func in self.datasources[i]["filters"]:
+                self.datasources[i]["dataset"] = apply_filter(
+                    self.datasources[i]["dataset"],
+                    column_name,
+                    filter_func,
+                    dry_run
+                )
+            self.datasources[i]["dataset"] = smart_from_pandas(self.datasources[i]["dataset"])
+
+
+def apply_cleaner(dataframe, column_name, cleaner_func):
+    logger.info(f"Running cleaner: {cleaner_func.__name__} on {column_name}")
+    func = lambda x: cleaner_func(x[column_name])
+    dataframe[column_name] = dataframe.progress_apply(func, axis=1)
+    return dataframe
+
+
+def apply_filter(dataframe, column_name, filter_func, dry_run):
+    logger.info(f"Running filter: {filter_func.__name__} on {column_name}")
+    criteria_column_name = f"{column_name}_{filter_func.__name__}_criteria"
+    func = lambda x: filter_func(x[column_name], dry_run=dry_run)
+    dataframe[criteria_column_name] = dataframe.progress_apply(func, axis=1)
+    logger.info(f"Criteria statistics:\n{dataframe[criteria_column_name].describe()}")
+    if not dry_run:
+        func = lambda x: x[criteria_column_name]
+        dataframe = dataframe[dataframe.progress_apply(func, axis=1)]
+        dataframe = dataframe.drop(
+            [criteria_column_name, "__index_level_0__"],
+            axis=1,
+            errors='ignore'
+        )
+
+    return dataframe
+
+
+def smart_from_pandas(df, chunk_size=200_000):
+    datasets = []
+    for g, batch in df.groupby(np.arange(len(df)) // chunk_size):
+        dataset = Dataset.from_pandas(batch, preserve_index=False)
+        datasets.append(dataset)
+    return concatenate_datasets(datasets)

chat_data_pipeline/preprocessor.py

@@ -0,0 +1,91 @@
+import gc
+import shutil
+
+from datasets import Dataset, load_from_disk
+
+from chat_data_pipeline.pipeline import logger
+from chat_data_pipeline import utils
+from chat_data_pipeline.minhash_deduplication import deduplicate
+
+
+class DataPreprocessor:
+    dataset: Dataset
+
+    def __init__(
+            self,
+            dataset,
+            column_name,
+            cleaners,
+            filters,
+            deduplication_config,
+            dry_run=False,
+            verbose=False
+    ):
+        self.dataset = dataset
+        self.column_name = column_name
+        self.cleaners = cleaners
+        self.filters = filters
+        self.deduplication_config = deduplication_config
+        self.dry_run = dry_run
+        self.verbose = verbose
+
+    def run(self):
+        self._clean_dataset()
+        self._filter_dataset()
+        if self.deduplication_config.get("do_deduplication", False):
+            self._deduplicate_dataset()
+        return self.dataset
+
+    def _clean_dataset(self):
+        if len(self.cleaners) > 0:
+            self.dataset = utils.run_cleaner(self.dataset, self.column_name, self.cleaners)
+        return self.dataset
+
+    def _filter_dataset(self):
+        for filter_func in self.filters:
+            dataset_length = len(self.dataset)
+            ids = range(dataset_length)
+            self.dataset = self.dataset.add_column("ids", ids)
+            filtered_dataset = utils.run_filter(
+                dataset=self.dataset,
+                column_name=self.column_name,
+                filter_func=filter_func,
+                dry_run=self.dry_run
+            )
+            self._print_filter_logs(filtered_dataset, filter_func.__name__)
+            self.dataset = filtered_dataset.remove_columns("ids")
+
+        return self.dataset
+
+    def _deduplicate_dataset(self):
+        dataset_length = len(self.dataset)
+        ids = range(dataset_length)
+        self.dataset = self.dataset.add_column("ids", ids)
+        # need to save to disk and load again, otherwise it is very slow
+        target_directory = "./.temp-dataset"
+        shutil.rmtree(target_directory, ignore_errors=True)
+        try:
+            self.dataset.save_to_disk(target_directory)
+        except PermissionError:
+            logger.info("Can not save dataset, nothing changed. Skipping...")
+        gc.collect()
+        self.dataset = load_from_disk(target_directory)
+        deduplicated_ds = deduplicate(
+            self.dataset,
+            column=self.column_name,
+            **self.deduplication_config.get("args", {})
+        )
+        self.dataset = deduplicated_ds.remove_columns("ids")
+        return self.dataset
+
+    def _print_filter_logs(self, filtered_dataset, filter_name):
+        original_length = len(self.dataset)
+        filtered_length = len(filtered_dataset)
+        reduced_percent = round(100 * (original_length - filtered_length) / original_length, 2)
+        logger.info(
+            f'Filtered by {filter_name} on {self.column_name}:\n'
+            f'{reduced_percent}% = {original_length - filtered_length:,} samples reduced\n'
+            f'New dataset size: {filtered_length:,} rows'
+        )
+        if self.verbose:
+            utils.print_sample_dropped_examples(self.dataset, filtered_dataset, num_samples=10)

chat_data_pipeline/utils.py

@@ -0,0 +1,339 @@
+import random
+import re
+from functools import partial
+from collections import Counter
+
+from datasets import load_dataset, Dataset, concatenate_datasets
+import numpy as np
+import pandas as pd
+import tqdm
+import yaml
+
+from chat_data_pipeline.pipeline import Pipeline, logger
+from chat_data_pipeline import cleaners as cln
+from chat_data_pipeline import filters as ftr
+from chat_data_pipeline.kenlm_model import KenlmModel
+
+
+def load_yaml(config_path):
+    with open(config_path, "r") as f:
+        return yaml.safe_load(f)
+
+
+def get_cleaners_from_config(config):
+    cleaner_funcs = []
+    cleaners = {}
+    if config.get("cleaners") is not None:
+        cleaners = config.get("cleaners", {})
+    for cleaner, do_clean in cleaners.items():
+        if do_clean:
+            cleaner_funcs.append(
+                getattr(cln, cleaner)
+            )
+    return cleaner_funcs
+
+
+def get_filters_from_config(config):
+    filter_funcs = []
+    filters = {}
+    if config.get("filters") is not None:
+        filters = config.get("filters", {})
+    for filter, value in filters.items():
+        args = {}
+        if value is not None:
+            args = value.get("args", {})
+        filter_func = custom_partial(
+            getattr(ftr, filter),
+            **args
+        )
+        filter_funcs.append(filter_func)
+    return filter_funcs
+
+
+def get_output_text_cleaners():
+    cleaners = [
+        cln.normalize_whitespace,
+        cln.normalize_punctuation,
+        cln.fix_utf8_encoding,
+        cln.remove_empty_lines
+    ]
+    return cleaners
+
+
+def get_input_text_cleaners():
+    cleaners = [
+        cln.normalize_whitespace,
+        cln.remove_empty_lines
+    ]
+    return cleaners
+
+
+def get_output_text_filters(filter_nsfw, filter_perplexity):
+    filters = [
+        custom_partial(
+            ftr.check_word_number,
+            min_word_threshold=5,
+            max_word_threshold=128,
+        ),
+        custom_partial(
+            ftr.check_completion,
+        ),
+        custom_partial(
+            ftr.check_char_repetition,
+            char_repetition_len=10,
+            char_repetition_threshold=0.2,
+        ),
+        custom_partial(
+            ftr.check_lowercase_ratio,
+            lowercase_threshold=0.75,
+        ),
+    ]
+    if filter_nsfw:
+        filters.append(
+            custom_partial(
+                ftr.check_nsfw_words,
+                flagged_words_threshold=0.025,
+            ),
+        )
+    if filter_perplexity:
+        filters.append(
+            custom_partial(
+                ftr.check_perplexity,
+                kenlm_model=_get_kenlm_model(),
+                min_perplexity_threshold=300,
+                max_perplexity_threshold=10_000
+            )
+        )
+    return filters
+
+
+def _get_kenlm_model():
+    kenlm_model = KenlmModel.from_pretrained(
+        model_dataset="wikipedia",
+        language="en",
+        lower_case=True,
+        remove_accents=True,
+        normalize_numbers=True,
+        punctuation=1,
+    )
+    return kenlm_model
+
+
+def get_input_text_filters():
+    filters = [
+        custom_partial(
+            ftr.check_lowercase_ratio,
+            lowercase_threshold=0.55,
+        ),
+    ]
+    return filters
+
+
+def get_truncation_filters(splitter_token):
+    filters = [
+        custom_partial(
+            ftr.check_truncation,
+            splitter_token=splitter_token
+        ),
+    ]
+    return filters
+
+
+def custom_partial(func, **args):
+    partial_func = partial(func, **args)
+    partial_func.__name__ = func.__name__
+    partial_func.__module__ = func.__module__
+    return partial_func
+
+
+def print_sample_dropped_examples(dataset, new_dataset, num_samples=5):
+    original_ids = dataset["ids"]
+    new_ids = new_dataset["ids"]
+    dropped_ids = set(original_ids) - set(new_ids)
+    num_samples = min(len(dropped_ids), num_samples)
+    ids_to_show = random.sample(list(dropped_ids), num_samples)
+    for id in ids_to_show:
+        logger.info(f"Dropped sample: {dataset[id]}")
+
+
+# Pipeline does not add column_name to newly added column with scores
+def rename_dry_run_columns(dataset, filter_column_name):
+    column_names = set(dataset.column_names)
+    column_names = column_names - {"output_text", "input_text", "summary", "user_id"}
+    columns_mapping = dict()
+    for column_name in column_names:
+        # Check if column already renamed by previous call of this function
+        if "__" not in column_name:
+            columns_mapping[column_name] = filter_column_name + "__" + column_name
+    dataset = dataset.rename_columns(columns_mapping)
+    return dataset
+
+
+def get_edit_dataset(dataset_path):
+    dataset = load_dataset(dataset_path, split="train", keep_in_memory=False)
+    dataset = prepare_edit_dataset(dataset)
+    return dataset
+
+
+def prepare_edit_dataset(dataset):
+    columns_mapping = {
+        "model_input": "input_text",
+        "edited_response": "output_text",
+    }
+    dataset = dataset.rename_columns(columns_mapping)
+    columns_to_keep = list(columns_mapping.values()) + ["user_id", "response"]
+    columns_to_remove = set(dataset.column_names) - set(columns_to_keep)
+    dataset = dataset.remove_columns(columns_to_remove)
+    return dataset
+
+
+def remove_unused_columns(dataset):
+    columns_to_keep = ["user_id", "input_text", "output_text"]
+    columns_to_remove = set(dataset.column_names) - set(columns_to_keep)
+    dataset = dataset.remove_columns(columns_to_remove)
+    return dataset
+
+
+def post_process_output_text(dataset):
+    df = dataset.to_pandas()
+    func = lambda x: " " + cln.clean_new_lines(x["output_text"]) + "\n"
+    df["output_text"] = df.progress_apply(func, axis=1)
+    dataset = Dataset.from_pandas(df)
+    return dataset
+
+
+def sample_datasets(datasets, proportions, target_size):
+    target_size = min(
+        [target_size] + [len(dataset) / proportion for proportion, dataset in zip(proportions, datasets)]
+    )
+    sampled_datasets = []
+    for proportion, dataset in zip(proportions, datasets):
+        sample_proportion = (target_size * proportion) / len(dataset)
+        sampled_dataset = sample_dataset(dataset, sample_proportion)
+        sampled_datasets.append(sampled_dataset)
+    merged_dataset = concatenate_datasets(sampled_datasets)
+    return merged_dataset
+
+
+def sample_dataset(dataset, size):
+    df = dataset.to_pandas()
+    grouped = df.groupby('user_id')
+    sample_groups = []
+    for _, sub_group in tqdm.tqdm(grouped):
+        sample_groups.append(_get_sample_group(sub_group, size=size))
+
+    df_subset = pd.concat(sample_groups)
+    df_subset = df_subset.drop(['__index_level_0__'], axis=1, errors='ignore')
+    dataset_subset = Dataset.from_pandas(df_subset)
+    return dataset_subset
+
+
+def _get_sample_group(group, size):
+    # helps with sampling superusers and do not touch small groups
+    if len(group) >= 5:
+        num_samples = int(len(group) * size)
+        group = group.sample(num_samples)
+    return group
+
+
+def split_dataset_by_filter(dataset, column_name, filter_func):
+    dataset_length = len(dataset)
+    ids = range(dataset_length)
+    dataset = dataset.add_column("ids", ids)
+    filtered_dataset = run_filter(dataset, column_name, filter_func, dry_run=False)
+
+    difference_dataset = _dataset_subtraction(dataset, filtered_dataset)
+
+    filtered_dataset = filtered_dataset.remove_columns("ids")
+    difference_dataset = difference_dataset.remove_columns("ids")
+
+    return filtered_dataset, difference_dataset
+
+
+def run_filter(dataset, column_name, filter_func, dry_run):
+    datasources = [
+        {
+            "dataset": dataset,
+            "name": "dataset",
+            "columns": [column_name],
+            "filters": [filter_func],
+            "cleaners": [],
+        },
+    ]
+    pipeline = Pipeline(datasources)
+    pipeline.run(dry_run=dry_run)
+    filtered_dataset = pipeline.datasources[0]["dataset"]
+    return filtered_dataset
+
+
+def run_cleaner(dataset, column_name, cleaners):
+    datasources = [
+        {
+            "dataset": dataset,
+            "name": "dataset",
+            "columns": [column_name],
+            "filters": [],
+            "cleaners": cleaners,
+        },
+    ]
+    pipeline = Pipeline(datasources)
+    pipeline.run(dry_run=True)
+    dataset = pipeline.datasources[0]["dataset"]
+    return dataset
+
+
+def _dataset_subtraction(minuend_dataset, subtrahend_dataset):
+    original_ids = minuend_dataset["ids"]
+    filtered_ids = subtrahend_dataset["ids"]
+    dropped_ids = set(original_ids) - set(filtered_ids)
+    original_df = minuend_dataset.to_pandas()
+    difference_df = original_df[original_df.ids.isin(dropped_ids)]
+    difference_df = difference_df.drop(['__index_level_0__'], axis=1, errors='ignore')
+    difference_dataset = Dataset.from_pandas(difference_df)
+    return difference_dataset
+
+
+def add_concatenated_column(dataset, column_name, special_token):
+    dataframe = dataset.to_pandas()
+    func = lambda x: x["response"] + special_token + x["output_text"]
+    dataframe[column_name] = dataframe.progress_apply(func, axis=1)
+    dataset = Dataset.from_pandas(dataframe)
+    return dataset
+
+
+def get_words(text):
+    return re.findall(r'\w+', text.lower())
+
+
+# Adapted from:
+# https://github.com/CarperAI/squeakily/blob/ba81f6e11fab424794d46cbf06d398ea2ad4a7f1/squeakily/filter.py#L81
+def get_char_repetition_ratio(doc, char_rep_len):
+    freq_char_ngrams = _get_frequency_ngrams(
+        doc, char_rep_len
+    )
+    if len(freq_char_ngrams) == 0:
+        return 0
+    char_rep_ratio = _calculate_char_repetition_ratio(freq_char_ngrams)
+    return char_rep_ratio
+
+
+def _calculate_char_repetition_ratio(freq_char_ngrams):
+    freq_char_ngrams = list(freq_char_ngrams.values())
+    freq_char_ngrams = sorted(freq_char_ngrams, reverse=True)
+    val_one = len([el for el in freq_char_ngrams if el == 1])
+    num_rep_char_ngrams = min(
+        int(np.sqrt(len(freq_char_ngrams))),
+        len(freq_char_ngrams) - val_one,
+    )
+    char_rep_ratio = sum(
+        freq_char_ngrams[:num_rep_char_ngrams]
+    ) / sum(freq_char_ngrams)
+    return char_rep_ratio
+
+
+def _get_frequency_ngrams(doc, n):
+    char_ngrams = [
+        doc[i: i + n] for i in range(len(doc) - n + 1)
+    ]
+    freq_char_ngrams = Counter(char_ngrams)
+    return freq_char_ngrams

experiments/instructions/vicuna-v0.yaml

@@ -0,0 +1,42 @@
+datasets:
+  - dataset_path: "AlekseyKorshuk/gpteacher-instruct-chatml"
+  - dataset_path: "AlekseyKorshuk/sharegpt-chatml"
+  - dataset_path: "AlekseyKorshuk/gpt4-llm-cleaned-chatml"
+
+output_dataset_path: "AlekseyKorshuk/vicuna-v0-chatml"
+verbose: False
+
+instruction_config:
+  cleaners:
+  filters:
+    check_word_number:
+      args:
+        min_word_threshold: 2
+        max_word_threshold: 9999999
+
+  deduplication:
+    do_deduplication: True
+    minhash_config:
+      ngram_size: 5
+      num_perm: 256
+      threshold: 0.7
+      min_ngram_size: 5
+
+response_config:
+  cleaners:
+  filters:
+    check_word_number:
+      args:
+        min_word_threshold: 10
+        max_word_threshold: 9999999
+    check_ethics:
+
+  deduplication:
+    do_deduplication: True
+    minhash_config:
+      ngram_size: 5
+      num_perm: 256
+      threshold: 0.7
+      min_ngram_size: 5
+
+

experiments/tiny-example.yaml

@@ -0,0 +1,41 @@
+datasets:
+  - dataset_path: "AlekseyKorshuk/gpteacher-instruct-chatml"
+
+output_dataset_path: "AlekseyKorshuk/tiny-example-chatml"
+verbose: False
+
+instruction_config:
+  cleaners:
+  filters:
+    check_word_number:
+      args:
+        min_word_threshold: 2
+        max_word_threshold: 9999999
+
+  deduplication:
+    do_deduplication: True
+    minhash_config:
+      ngram_size: 5
+      num_perm: 256
+      threshold: 0.7
+      min_ngram_size: 5
+
+response_config:
+  cleaners:
+    fix_utf8_encoding: true
+  filters:
+    check_word_number:
+      args:
+        min_word_threshold: 10
+        max_word_threshold: 9999999
+    check_ethics:
+
+  deduplication:
+    do_deduplication: True
+    minhash_config:
+      ngram_size: 5
+      num_perm: 256
+      threshold: 0.7
+      min_ngram_size: 5
+
+

main.py

@@ -0,0 +1,139 @@
+import os
+
+import click
+from datasets import load_dataset, concatenate_datasets
+
+from chat_data_pipeline.pipeline import logger
+from chat_data_pipeline import utils
+from chat_data_pipeline.preprocessor import DataPreprocessor
+
+PAD = 32
+
+
+@click.command()
+@click.option('--config_path')
+def main(config_path):
+    config = utils.load_yaml(config_path)
+    dataset_paths = [dataset["dataset_path"] for dataset in config["datasets"]]
+    output_dataset_path = config["output_dataset_path"]
+    verbose = config.get("verbose", False)
+
+    instruction_config = config["instruction_config"]
+    response_config = config["response_config"]
+
+    dataset = combine_datasets(dataset_paths)
+
+    dataset = dataset.map(
+        convert_to_input_output,
+        batched=True,
+        num_proc=os.cpu_count(),
+        remove_columns=list(dataset.features),
+        desc="Converring to I/O..."
+    )
+
+    dataset = dataset.map(
+        add_content_columns,
+        batched=False,
+        num_proc=os.cpu_count(),
+        desc="Adding content column..."
+    )
+
+    print(utils.get_cleaners_from_config(response_config))
+    print(utils.get_filters_from_config(response_config))
+    print(response_config.get("deduplication", {}))
+    preprocessor = DataPreprocessor(
+        dataset=dataset,
+        column_name="response",
+        cleaners=utils.get_cleaners_from_config(response_config),
+        filters=utils.get_filters_from_config(response_config),
+        deduplication_config=response_config.get("deduplication", {}),
+        verbose=verbose,
+    )
+    dataset = preprocessor.run()
+
+    cleaners = utils.get_cleaners_from_config(instruction_config)
+    if len(cleaners) > 0:
+        logger.warning("Cleaner does not work on instructions. Cleaners set to empty list.")
+    preprocessor = DataPreprocessor(
+        dataset=dataset,
+        column_name="instruction",
+        cleaners=[],
+        filters=utils.get_filters_from_config(instruction_config),
+        deduplication_config=instruction_config.get("deduplication", {}),
+        verbose=verbose,
+    )
+    dataset = preprocessor.run()
+
+    prepared_dataset_chatml = dataset.map(
+        convert_to_chatml,
+        batched=False,
+        num_proc=os.cpu_count(),
+        remove_columns=list(dataset.features)
+    )
+    prepared_dataset_chatml = prepared_dataset_chatml.shuffle(seed=42)
+    prepared_dataset_chatml.push_to_hub(output_dataset_path)
+    logger.info(prepared_dataset_chatml)
+
+
+def combine_datasets(dataset_paths):
+    datasets = []
+    for dataset_path in dataset_paths:
+        dataset = load_dataset(dataset_path)
+        dataset = concatenate_datasets(list(dataset.values()))
+        if "source" not in dataset.features:
+            dataset = dataset.add_column("source", [dataset_path] * len(dataset))
+        datasets.append(dataset)
+    dataset = concatenate_datasets(datasets)
+    return dataset
+
+
+def convert_to_input_output(examples):
+    sources = []
+    inputs = []
+    outputs = []
+    for conversation, source in zip(examples["conversation"], examples["source"]):
+        input = []
+        for message in conversation:
+            if message["do_train"]:
+                inputs.append(input.copy())
+                outputs.append(message)
+                sources.append(source)
+            input.append(message)
+    return {
+        "input": inputs,
+        "output": outputs,
+        "source": sources
+    }
+
+
+def add_content_columns(example):
+    response = example["output"]["content"].strip()
+    instruction = ""
+    if len(example["input"]) > 0:
+        instruction = example["input"][-1]["content"].strip()
+    return {
+        "instruction": instruction,
+        "response": response,
+    }
+
+
+def convert_to_chatml(example):
+    conversation = []
+    for message in example["input"]:
+        message["do_train"] = False
+        conversation.append(message)
+    conversation.append(
+        {
+            "content": example["response"],
+            "role": example["output"]["role"],
+            "do_train": True,
+        }
+    )
+    return {
+        "conversation": conversation,
+        "source": example["source"]
+    }
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+ftfy==6.1.1
+https://github.com/kpu/kenlm/archive/master.zip
+sentencepiece==0.1.97
+datasketch==1.5.8
+dpu_utils==0.6.0
+datasets==2.11.0
+click==8.1.3
+rich==13.3.4
+typer==0.9.0