Add files using upload-large-folder tool

cc-multilingual-main/README.md

@@ -0,0 +1,56 @@
+# cc-multilingual
+Downloading and dedup indic multi-lingual from CommonCrawl
+### Installation for cc_net
+```sh
+cd cc_net/
+make install .
+```
+### Choose a snapshot: snapshot-id
+
+#### Step 1: Edit the config.myconfig.json file
+```json
+"dump": "snapshot-id",
+"num_shards": 1600,
+"lang_whitelist": ["as","bn","gu","kn","hi","ml","mr","ne","or","pb","sa","sd","ta","ur","te","ks","sat","mai","mni","kok","doi","brx"],
+"mine_num_processes": 16,
+"pipeline": [
+    "lid",
+    "keep_lang",
+    "pp_bucket",
+    "split_by_lang"
+],
+"target_size": "100M",
+"output_dir": "data",
+"mined_dir": "mined",
+"cache_dir": "wet_cache"
+```
+
+#### Step 2: (Optional) Download data into cache
+```sh
+wget wet_file_path
+python3 script.py wet.paths.gz 90 wet_cache/2023-40/
+```
+#### Step 3: Run the pipeline
+```sh
+python3 -m cc_net --config config/myconfig.json
+```
+
+## Deduplication
+```
+pip install app/requirements.txt
+```
+#### Step1: Add list of files downloaded from cc_net to listings/file.txt in format lang_shard.json.gz
+
+#### Step 2: Computing minhash signatures
+```
+python3 app/src/pipeline.py --input_base_uri "file://path/to/ccnet/data" --output_base_uri "/path/to/output" --artifacts_dir "file:///path/to/empty/artifacts" --input /path/to/listings/file.txt --cc_snapshot_id 2023-50 --langs "hi" --inputs_per_process 5 --minhash_num_permutations 128 --minhash_ngram_size 13
+```
+
+#### Step 3: Applying bloomfilter
+```
+python3 app/src/bloomfilter.py --listings /path/to/listings/file.txt --input_base_uri "file://path/to/ccnet/data" --output_dir "/path/to/output" --parallel_readers 32 --batch_size 10 
+```
+#### Step 4: Running LSH
+```
+python3 app/src/run_lsh.py --listings "/path/to/minhash-signature/listings/file.txt" --input_base_uri "file:///path/to/minhash-signature/files" --output_dir "/path/to/output" --similarity "0.8" --num_perm "128"
+```

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/constants.py

@@ -0,0 +1,2 @@
+PRECISION = 8
+CCNET_LABEL = "__label__cc"

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/data_types.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from msgspec import Struct
+
+from typing import List, Tuple, Optional, Dict
+from typing_extensions import TypeAlias
+
+ScoreType: TypeAlias = Tuple[int, int, Optional[float]]
+SignalType: TypeAlias = List[ScoreType]
+
+
+@dataclass
+class TextSlice:
+    text: str
+    start: int
+    end: int
+
+    def __len__(self):
+        return len(self.text)
+
+
+class InputSpec(Struct):
+    raw_content: str
+    url: str
+    nlines: int
+    # original_nlines: int
+    source_domain: str
+    length: int
+    # original_length: int
+    language: str
+    language_score: float
+    # perplexity: float
+    bucket: str
+    digest: str
+    cc_segment: str
+    date_download: str
+
+
+class OutputSpec(Struct):
+    id: str
+    id_int: int
+    metadata: Dict[str, str]
+    quality_signals: Dict[str, List[Tuple[int, int, Optional[float]]]]
+
+
+

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/document.py

@@ -0,0 +1,178 @@
+from nltk.tokenize import WordPunctTokenizer
+import re
+from typing import Optional, Tuple, Callable
+
+from utilities.text import normalize, form_ngrams
+from core.data_types import TextSlice
+from core.quality_signals.utils.dsir import hash_feature
+
+_word_tokenizer = WordPunctTokenizer()
+
+
+def _compute_ngrams(text_seq, n):
+    return tuple(form_ngrams(iter(text_seq), n))
+
+
+def split_paragraphs(
+        text: str, normalizer: Callable[[str], str], remove_empty: bool = True
+) -> Tuple[TextSlice]:
+    """
+    This function is adapted from dolma: https://github.com/allenai/dolma
+
+    Split a string into paragraphs. A paragraph is defined as a sequence of
+    zero or more characters, followed by a newline character, or a sequence
+     of one or more characters, followed by the end of the string.
+    """
+    text_slices = tuple(
+        TextSlice(normalizer(text[match.start():match.end()]), match.start(),
+                  match.end())
+        for match in re.finditer(r"([^\n]*\n|[^\n]+$)", text)
+    )
+
+    if remove_empty is True:
+        text_slices = tuple(
+            text_slice for text_slice in text_slices if text_slice[0].strip()
+        )
+
+    return text_slices
+
+
+class Document:
+    __slots__ = (
+        "_raw_content", "_normalized_content", "_raw_lines",
+        "_normalized_lines", "_raw_words", "_normalized_words",
+        "_num_raw_words", "_num_normalized_words", "_domain", "_raw_2grams",
+        "_raw_3grams", "_norm_2grams", "_norm_3grams", "_norm_4grams",
+        "_hash_features"
+    )
+
+    def __init__(
+            self, content: str, domain: Optional[str],
+            precompute_ngrams: bool = False,
+            precompute_hash_features: bool = False,
+            dsir_buckets: Optional[int] = None
+    ):
+        self._raw_content = content
+        self._domain = domain
+
+        # the normalized content: lowercased and punctuation removed
+        self._normalized_content = normalize(content)
+
+        # the lines of the document (split by newline)
+        self._raw_lines: Tuple[TextSlice] = split_paragraphs(
+            text=content, normalizer=lambda x: x, remove_empty=False
+        )
+
+        # the lines of the document (split by newline), normalized
+        self._normalized_lines: Tuple[TextSlice] = split_paragraphs(
+            text=content, normalizer=normalize, remove_empty=False
+        )
+
+        # the words of the document after normalization
+        self._raw_words = tuple(_word_tokenizer.tokenize(self._raw_content))
+
+        # the normalized words of the document (split by whitespace)
+        self._normalized_words = tuple(self._normalized_content.split())
+
+        # get number of words before and after normalization
+        self._num_raw_words = len(self._raw_words)
+        self._num_normalized_words = len(self._normalized_words)
+
+        # precompute ngrams
+        if precompute_ngrams:
+            # raw grams
+            self._raw_2grams = _compute_ngrams(self._raw_words, 2)
+            self._raw_3grams = _compute_ngrams(self._raw_words, 3)
+
+            # normalized grams
+            self._norm_2grams = _compute_ngrams(self._normalized_words, 2)
+            self._norm_3grams = _compute_ngrams(self._normalized_words, 3)
+            self._norm_4grams = _compute_ngrams(self._normalized_words, 4)
+        else:
+            self._raw_2grams = None
+            self._raw_3grams = None
+            self._norm_2grams = None
+            self._norm_3grams = None
+            self._norm_4grams = None
+
+        # precomupte hash features
+        if precompute_hash_features:
+            bigrams = self._raw_2grams or _compute_ngrams(self._raw_words, 2)
+            self._hash_features = hash_feature(
+                unigrams=self._raw_words,
+                bigrams=bigrams,
+                buckets=dsir_buckets
+            )
+        else:
+            self._hash_features = None
+
+    def __len__(self):
+        return len(self._raw_content)
+
+    @property
+    def raw_content(self):
+        return self._raw_content
+
+    @property
+    def normalized_content(self):
+        return self._normalized_content
+
+    @property
+    def raw_lines(self):
+        return self._raw_lines
+
+    @property
+    def normalized_lines(self):
+        return self._normalized_lines
+
+    @property
+    def raw_words(self):
+        return self._raw_words
+
+    @property
+    def normalized_words(self):
+        return self._normalized_words
+
+    @property
+    def num_raw_words(self):
+        return self._num_raw_words
+
+    @property
+    def num_normalized_words(self):
+        return self._num_normalized_words
+
+    @property
+    def domain(self):
+        return self._domain
+
+    @property
+    def raw_1grams(self):
+        return self._raw_words
+
+    @property
+    def raw_2grams(self):
+        return self._raw_2grams
+
+    @property
+    def raw_3grams(self):
+        return self._raw_3grams
+
+    @property
+    def norm_1grams(self):
+        return self._normalized_words
+
+    @property
+    def norm_2grams(self):
+        return self._norm_2grams
+
+    @property
+    def norm_3grams(self):
+        return self._norm_3grams
+
+    @property
+    def norm_4grams(self):
+        return self._norm_4grams
+
+    @property
+    def hash_features(self):
+        return self._hash_features

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/exceptions.py

@@ -0,0 +1,18 @@
+class S3ReadError(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class S3WriteError(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class LocalReadError(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class UnknownReadError(Exception):
+    def __init__(self, message):
+        super().__init__(message)

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/quality_signals/base.py

@@ -0,0 +1,30 @@
+from core.document import Document
+from core.data_types import SignalType
+
+
+class RPSBase:
+    r""" Base class for RP signal functions. Each child class must implement
+    the __call__ method. The __call__ method takes a document as input and
+    returns a score. """
+    DATA_TYPE = SignalType
+
+    RPS_PREFIX: str = "RPS_"
+
+    __slots__ = ["__field_name"]
+
+    def __init__(self, *args, **kwargs):  # noqa
+        # make sure all classes start with RPS_; this is to ensure that
+        # the get_rule_based_signals function works correctly when new signal
+        # functions are added
+        assert self.__class__.__name__.startswith(self.RPS_PREFIX), \
+            f"Name of signal function must" \
+            f" start with {self.RPS_PREFIX}; got {self.__class__.__name__}"
+
+        self.__field_name = self.__class__.__name__.lower()
+
+    def __call__(self, document: Document):
+        raise NotImplementedError
+
+    @property
+    def field_name(self):
+        return self.__field_name

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/quality_signals/classifiers.py

@@ -0,0 +1,114 @@
+import sys
+from typing import List, Tuple, Type
+import fasttext
+
+from core.constants import PRECISION, CCNET_LABEL
+from core.quality_signals.base import RPSBase
+from core.document import Document
+from core.data_types import SignalType
+from core.quality_signals.utils.classifiers import \
+    preprocess_quality_classifier
+from utilities.register.registry_utils import *
+
+__all__ = [
+    "register_classifier_callables", "classifier_schema"
+]
+
+
+def classifier_schema() -> List[Tuple[str, Type]]:
+    r""" Returns a list of signal names and their data types """
+    return signal_schema(module=sys.modules[__name__])
+
+
+def register_classifier_callables(
+        wikiref_model: str,
+        palm_model: str,
+        wikipedia_model: str
+) -> List[RPSBase]:
+    r""" Returns a list of signal functions (i.e., RPSBase instances) that
+    are used to extract content signals from a document.
+
+    Args:
+        wikiref_model: A fasttext model trained on Wikipedia references.
+        palm_model: A fasttext model trained on ccnet vs
+            {books, openwebtext, wikipedia}.
+        wikipedia_model: A fasttext model trained on Wikipedia articles.
+
+    Returns:
+        A list of signal function class instances.
+    """
+    return list(map(
+        lambda cls: cls(
+            wikiref_model=wikiref_model,
+            palm_model=palm_model,
+            wikipedia_model=wikipedia_model,
+        ),
+        get_callables_from_module(module=sys.modules[__name__])
+    ))
+
+
+class BaseMLSignal(RPSBase):
+    __slots__ = "_ft_model"
+
+    def __init__(self, ft_model_file: str):
+        super(BaseMLSignal, self).__init__()
+        if ft_model_file is None:
+            self._ft_model = None
+        else:
+            self._ft_model = fasttext.load_model(str(ft_model_file))
+
+    def __call__(self, document: Document) -> SignalType:
+        if self._ft_model is None:
+            return [(0, len(document), None)]
+
+        if len(document.raw_content) == 0:
+            return [(0, len(document), None)]
+
+        text = preprocess_quality_classifier(document=document)
+        pred = self._ft_model.predict(text=text)
+
+        (pred_label, pred_prob) = pred
+        pred_label = pred_label[0]
+        pred_prob = pred_prob[0]
+
+        if pred_label == CCNET_LABEL:
+            high_quality_score = 1 - pred_prob
+        else:
+            high_quality_score = pred_prob
+
+        score = round(float(high_quality_score), PRECISION)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_ML_Wikiref_Score(BaseMLSignal):  # noqa
+    r""" Fasttext classifier prediction for the document being a Wikipedia
+    reference. This is the same fasttext model as in the RedPajama-1T
+    dataset."""
+    __slots__ = ()
+
+    def __init__(self, wikiref_model: str, *args, **kwargs):  # noqa
+        super(RPS_Doc_ML_Wikiref_Score, self).__init__(
+            ft_model_file=wikiref_model
+        )
+
+
+class RPS_Doc_ML_Palm_Score(BaseMLSignal):  # noqa
+    r""" Fasttext classifier prediction for the document being a Wikipedia
+    article, OpenWebText sample or a RedPajama-V1 book."""
+    __slots__ = ()
+
+    def __init__(self, palm_model: str, *args, **kwargs):  # noqa
+        super(RPS_Doc_ML_Palm_Score, self).__init__(
+            ft_model_file=palm_model
+        )
+
+
+class RPS_Doc_ML_Wikipedia_Score(BaseMLSignal):  # noqa
+    r""" Fasttext classifier prediction for the document being a Wikipedia
+    article."""
+    __slots__ = ()
+
+    def __init__(self, wikipedia_model: str, *args, **kwargs):  # noqa
+        super(RPS_Doc_ML_Wikipedia_Score, self).__init__(
+            ft_model_file=wikipedia_model
+        )

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/quality_signals/content.py

@@ -0,0 +1,189 @@
+import re
+import sys
+import operator
+from pathlib import Path
+from typing import List, Tuple, Type
+
+from core.constants import PRECISION
+from core.quality_signals.base import RPSBase
+from core.quality_signals.utils.stop_words import get_stop_words
+from core.document import Document
+from core.data_types import SignalType
+from core.quality_signals.utils.content import \
+    load_bad_words, load_bad_urls_index
+from utilities.register.registry_utils import *
+from utilities.text import form_ngrams
+
+__all__ = ["register_content_callables", "content_schema"]
+
+
+def content_schema() -> List[Tuple[str, Type]]:
+    r""" Returns a list of signal names and their data types """
+    return signal_schema(module=sys.modules[__name__])
+
+
+def register_content_callables(
+        language: str, bad_urls_dir: str, bad_words_dir: str
+) -> List[RPSBase]:
+    r""" Returns a list of signal functions (i.e., RPSBase instances) that
+    are used to extract content signals from a document.
+
+    Args:
+        language: The language of the document.
+        bad_urls_dir: directory containing the UT1 blacklist.
+        bad_words_dir: directory containing the LDNOOBW blacklist.
+
+    Returns:
+        A list of signal function class instances.
+    """
+    return list(map(
+        lambda cls: cls(
+            language=language,
+            bad_urls_dir=bad_urls_dir,
+            bad_words_dir=bad_words_dir
+        ),
+        get_callables_from_module(module=sys.modules[__name__])
+    ))
+
+
+class RPS_Doc_LDNOOBW_Words(RPSBase):  # noqa
+    r""" The number of sequences of words that are contained in the
+    List-of-Dirty-Naughty-Obscene-and-Otherwise-Bad-Words blocklist. The
+    blocklist is obtained from
+    https://github.com/LDNOOBW/List-of-Dirty-Naughty-Obscene-and-Otherwise-Bad-Words
+    """
+    __slots__ = ["_block_words", "_gram_vals"]
+
+    def __init__(
+            self, bad_words_dir: str, language: str, *args, **kwargs  # noqa
+    ):
+        super(RPS_Doc_LDNOOBW_Words, self).__init__()
+        self._block_words = load_bad_words(
+            bad_words_dir=Path(bad_words_dir), lang=language
+        )
+
+        # cache the number of words in each block list entry
+        self._gram_vals = set(map(
+            lambda w: 1 + operator.countOf(w, " "), self._block_words
+        ))
+
+    def __call__(self, document: Document) -> SignalType:
+        if len(document.normalized_content) == 0:
+            return [(0, len(document), .0)]
+
+        num_dirty = 0
+
+        # for each ngram value, count the number of ngrams in the document
+        # which are also in the block words list
+        for n in self._gram_vals:
+            if n == 1:
+                num_dirty += sum(
+                    1 for _ in filter(
+                        lambda w: w in self._block_words,
+                        document.normalized_words
+                    )
+                )
+                continue
+
+            num_dirty += sum(
+                1 for _ in filter(
+                    lambda t: " ".join(t) in self._block_words,
+                    # try to fetch the cached ngrams, otherwise compute them
+                    # on the fly
+                    getattr(document, f"norm_{n}grams", None)
+                    or
+                    form_ngrams(iter(document.normalized_words), n)
+                )
+            )
+
+        score = float(num_dirty)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Lorem_Ipsum(RPSBase):  # noqa
+    r""" The ratio between the number of occurences of 'lorem ipsum'
+    and the number of characters in the text after normalization. Text is
+    normalized by lowercasing and removing punctuation. """
+    SEARCH_TEXT = "lorem ipsum"
+    SEARCH_REGEX = re.compile(r"lorem ipsum", re.IGNORECASE)
+
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        if len(document.normalized_content) == 0:
+            return [(0, len(document), 0.0)]
+
+        if self.SEARCH_TEXT not in document.normalized_content:
+            return [(0, len(document), .0)]
+
+        num_occurences = len(self.SEARCH_REGEX.findall(
+            document.normalized_content
+        ))
+
+        score = float(num_occurences) / len(document.normalized_content)
+        score = round(score, PRECISION)
+
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Curly_Bracket(RPSBase):  # noqa
+    r""" The ratio between the number of occurences of '{' or '}' and the
+    number of characters in the raw text. """
+    SEARCH_TEXT = ("{", "}")
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        if len(document.raw_content) == 0:
+            return [(0, len(document), .0)]
+
+        if all(map(lambda x: x not in document.raw_content, self.SEARCH_TEXT)):
+            return [(0, len(document), .0)]
+
+        num_occurences = sum(
+            map(lambda x: operator.countOf(document.raw_content, x),
+                self.SEARCH_TEXT)
+        )
+
+        score = float(num_occurences) / len(document.raw_content)
+        score = round(score, PRECISION)
+
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_UT1_Blacklist(RPSBase):  # noqa
+    r""" An categorical id of the list of categories of the domain of the
+    document. Categories are obtained from the UT1 blacklist.
+    """
+    __slots__ = ["_ut1_mapping"]
+
+    def __init__(self, bad_urls_dir: str, *args, **kwargs):  # noqa
+        super(RPS_Doc_UT1_Blacklist, self).__init__()
+        # self._ut1_mapping = load_bad_urls_index(Path(bad_urls_dir))
+        self._ut1_mapping = {}
+
+    def __call__(self, document: Document) -> SignalType:
+        score: int = self._ut1_mapping.get(document.domain, None)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Stop_Word_Fraction(RPSBase):  # noqa
+    r""" The ratio between the number of stop words and the number of words in
+    the document. """
+    __slots__ = ["_stop_words"]
+
+    def __init__(self, language: str, *args, **kwargs):  # noqa
+        super(RPS_Doc_Stop_Word_Fraction, self).__init__()
+        self._stop_words = get_stop_words(language)
+
+    def __call__(self, document: Document) -> SignalType:
+        if len(document.normalized_words) == 0:
+            return [(0, len(document), .0)]
+
+        num_stop_words = sum(
+            map(lambda w: w in self._stop_words, document.raw_words)
+        )
+
+        score = float(num_stop_words) / document.num_raw_words
+        score = round(score, PRECISION)
+
+        return [(0, len(document), score)]

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/quality_signals/importance_weights.py

@@ -0,0 +1,303 @@
+import numpy as np
+import scipy.stats as stats
+import sys
+from typing import List, Tuple, Type, Optional
+from pathlib import Path
+
+from core.constants import PRECISION
+from core.quality_signals.base import RPSBase
+from core.quality_signals.utils.dsir import hash_feature
+from core.document import Document
+from core.data_types import SignalType
+
+from utilities.register.registry_utils import *
+from utilities.text import form_ngrams
+
+__all__ = [
+    "register_importance_weights_callables",
+    "importance_weights_schema"
+]
+
+
+def importance_weights_schema() -> List[Tuple[str, Type]]:
+    r""" Returns a list of signal names and their data types """
+    return signal_schema(module=sys.modules[__name__])
+
+
+def register_importance_weights_callables(
+        source_fps: Optional[Tuple[str]],
+        wiki_fps: Optional[Tuple[str]],
+        openwebtext_fps: Optional[Tuple[str]],
+        books_fps: Optional[Tuple[str]],
+        language: str
+) -> List[RPSBase]:
+    r""" Returns a list of signal functions (i.e., RPSBase instances) that
+    are used to extract content signals from a document.
+
+    Returns:
+        A list of signal function class instances.
+    """
+    return list(map(
+        lambda cls: cls(
+            language=language,
+            source_fps=source_fps,
+            wiki_fps=wiki_fps,
+            openwebtext_fps=openwebtext_fps,
+            books_fps=books_fps
+        ),
+        get_callables_from_module(module=sys.modules[__name__])
+    ))
+
+
+class Base_Importance(RPSBase):  # noqa
+    r""" Base class for functions which return the log ratio of the likelihood
+    of the document's features with respect to the target domain
+    versus the source domain. """
+
+    __slots__ = (
+        "_log_diff_dist", "_feature_dim", "_target_lambda",
+        "_source_lambda", "_length_correction"
+    )
+
+    def __init__(
+            self,
+            target_fps: Tuple[str, str],
+            source_fps: Tuple[str, str],
+            language: str,
+            length_correction: bool = False
+    ):
+        super(Base_Importance, self).__init__()
+        self._length_correction = length_correction
+
+        if target_fps is None or source_fps is None:
+            self._log_diff_dist = None
+            self._feature_dim = None
+            return
+
+        target_count_fp, target_lambbda_fp = target_fps
+        source_count_fp, source_lambda_fp = source_fps
+
+        assert language == Path(target_count_fp).stem.split(".")[1], \
+            f"Language mismatch between {target_count_fp} and {language}"
+
+        assert language == Path(source_count_fp).stem.split(".")[1], \
+            f"Language mismatch between {target_count_fp} and {language}"
+
+        # load hash counts
+        target_counts = np.load(target_count_fp)
+        target_dist = target_counts / target_counts.sum()
+        source_counts = np.load(source_count_fp)
+        source_dist = source_counts / source_counts.sum()
+
+        if length_correction:
+            self._target_lambda = np.load(target_lambbda_fp)
+            self._source_lambda = np.load(source_lambda_fp)
+        else:
+            self._target_lambda = None
+            self._source_lambda = None
+
+        # compute log diff dist
+        self._feature_dim = target_counts.shape[0]
+        self._log_diff_dist = np.array(
+            np.log(target_dist + 1e-8) - np.log(source_dist + 1e-8)
+        )
+
+    def __call__(self, document: Document) -> SignalType:
+        if self._log_diff_dist is None:
+            return [(0, len(document), None)]
+
+        doc_len = len(document)
+
+        if doc_len == 0:
+            return [(0, doc_len, None)]
+
+        # try to fetch cached features, if not compute them
+        features = (
+            document.hash_features
+            if document.hash_features is not None
+            else
+            hash_feature(
+                unigrams=document.raw_words,
+                # fetch cached bigrams, otherwise comptue them
+                bigrams=(
+                        document.raw_2grams
+                        or
+                        tuple(form_ngrams(iter(document.raw_words), 2))
+                ),
+                buckets=self._feature_dim
+            )
+        )
+
+        logratio = np.inner(features, self._log_diff_dist)
+        score = float(logratio)
+
+        if not self._length_correction:
+            score = round(score, PRECISION)
+            return [(0, doc_len, score)]
+
+        # correct for the length assuming a Poisson distribution
+        return self.__add_length_penalty(score, doc_len)
+
+    def __add_length_penalty(self, score, doc_len):
+        # correct for the length assuming a Poisson distribution
+        len_prob_source = stats.poisson.pmf(doc_len, self._source_lambda)
+        len_prob_target = stats.poisson.pmf(doc_len, self._target_lambda)
+
+        len_correction = np.log(len_prob_target + 1e-8) - \
+                         np.log(len_prob_source + 1e-8)
+
+        score += float(len_correction)
+        score = round(score, PRECISION)
+        return [(0, doc_len, score)]
+
+
+class RPS_Doc_Wikipedia_Importance(Base_Importance):  # noqa
+    r""" Given a bag of {1,2}-wordgram model trained on Wikipedia articles p,
+    and a model trained on the source domain q. This is the logarithm of the
+    ratio p(doc)/q(doc). If length_correction is enabled, then the length of
+    score is adjusted by adding the term log(p_poisson(len) / q_poisson(len))
+    to the final score.
+    """
+    __slots__ = ()
+
+    def __init__(
+            self,
+            wiki_fps: Tuple[str, str],
+            source_fps: Tuple[str, str],
+            language: str,
+            *args, **kwargs  # noqa
+    ):
+        super(RPS_Doc_Wikipedia_Importance, self).__init__(
+            target_fps=wiki_fps,
+            source_fps=source_fps,
+            language=language,
+            length_correction=False
+        )
+
+
+class RPS_Doc_Wikipedia_Importance_Length_Correction(  # noqa
+    Base_Importance
+):
+    r""" Given a bag of {1,2}-wordgram model trained on Wikipedia articles p,
+    and a model trained on the source domain q. This is the logarithm of the
+    ratio p(doc)/q(doc). If length_correction is enabled, then the length of
+    score is adjusted by adding the term log(p_poisson(len) / q_poisson(len))
+    to the final score. Corrects for length by adding a length penalty term.
+    """
+    __slots__ = ()
+
+    def __init__(
+            self,
+            wiki_fps: Tuple[str, str],
+            source_fps: Tuple[str, str],
+            language: str,
+            *args, **kwargs  # noqa
+    ):
+        super(RPS_Doc_Wikipedia_Importance_Length_Correction,
+              self).__init__(
+            target_fps=wiki_fps,
+            source_fps=source_fps,
+            language=language,
+            length_correction=True
+        )
+
+
+class RPS_Doc_Books_Importance(Base_Importance):  # noqa
+    r""" Given a bag of {1,2}-wordgram model trained on Books p,
+    and a model trained on the source domain q. This is the logarithm of the
+    ratio p(doc)/q(doc). If length_correction is enabled, then the length of
+    score is adjusted by adding the term log(p_poisson(len) / q_poisson(len))
+    to the final score.
+    """
+    __slots__ = ()
+
+    def __init__(
+            self,
+            books_fps: Tuple[str, str],
+            source_fps: Tuple[str, str],
+            language: str,
+            *args, **kwargs  # noqa
+    ):
+        super(RPS_Doc_Books_Importance, self).__init__(
+            target_fps=books_fps,
+            source_fps=source_fps,
+            language=language,
+            length_correction=False
+        )
+
+
+class RPS_Doc_Books_Importance_Length_Correction(  # noqa
+    Base_Importance
+):  # noqa
+    r""" Given a bag of {1,2}-wordgram model trained on Books p,
+    and a model trained on the source domain q. This is the logarithm of the
+    ratio p(doc)/q(doc). If length_correction is enabled, then the length of
+    score is adjusted by adding the term log(p_poisson(len) / q_poisson(len))
+    to the final score. Corrects for length by adding a length penalty term.
+    """
+    __slots__ = ()
+
+    def __init__(
+            self,
+            books_fps: Tuple[str, str],
+            source_fps: Tuple[str, str],
+            language: str,
+            *args, **kwargs  # noqa
+    ):
+        super(RPS_Doc_Books_Importance_Length_Correction, self).__init__(
+            target_fps=books_fps,
+            source_fps=source_fps,
+            language=language,
+            length_correction=True
+        )
+
+
+class RPS_Doc_OpenWebText_Importance(Base_Importance):  # noqa
+    r""" Given a bag of {1,2}-wordgram model trained on OpenWebText p,
+    and a model trained on the source domain q. This is the logarithm of the
+    ratio p(doc)/q(doc). If length_correction is enabled, then the length of
+    score is adjusted by adding the term log(p_poisson(len) / q_poisson(len))
+    to the final score.
+    """
+    __slots__ = ()
+
+    def __init__(
+            self,
+            openwebtext_fps: Tuple[str, str],
+            source_fps: Tuple[str, str],
+            language: str,
+            *args, **kwargs  # noqa
+    ):
+        super(RPS_Doc_OpenWebText_Importance, self).__init__(
+            target_fps=openwebtext_fps,
+            source_fps=source_fps,
+            language=language,
+            length_correction=False
+        )
+
+
+class RPS_Doc_OpenWebText_Importance_Length_Correction(  # noqa
+    Base_Importance):  # noqa
+    r""" Given a bag of {1,2}-wordgram model trained on OpenWebText p,
+    and a model trained on the source domain q. This is the logarithm of the
+    ratio p(doc)/q(doc). If length_correction is enabled, then the length of
+    score is adjusted by adding the term log(p_poisson(len) / q_poisson(len))
+    to the final score. Corrects for length by adding a length penalty term.
+    """
+    __slots__ = ()
+
+    def __init__(
+            self,
+            openwebtext_fps: Tuple[str, str],
+            source_fps: Tuple[str, str],
+            language: str,
+            *args, **kwargs  # noqa
+    ):
+        super(
+            RPS_Doc_OpenWebText_Importance_Length_Correction, self
+        ).__init__(
+            target_fps=openwebtext_fps,
+            source_fps=source_fps,
+            language=language,
+            length_correction=True
+        )

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/quality_signals/lines.py

@@ -0,0 +1,153 @@
+import sys
+from typing import List, Tuple, Type
+
+from core.constants import PRECISION
+from core.quality_signals.base import RPSBase
+from core.data_types import SignalType, ScoreType, TextSlice
+from core.document import Document
+from utilities.register.registry_utils import *
+
+__all__ = [
+    "register_lines_callables", "lines_schema"
+]
+
+
+def lines_schema() -> List[Tuple[str, Type]]:
+    r""" Returns a list of signal names and their data types """
+    return signal_schema(module=sys.modules[__name__])
+
+
+def register_lines_callables() -> List[RPSBase]:
+    r""" Returns a list of signal functions (i.e., RPSBase instances) that
+    are used to extract line signals from a document.
+
+    Returns:
+        A list of signal function class instances.
+    """
+    return list(map(
+        lambda cls: cls(),
+        get_callables_from_module(module=sys.modules[__name__])
+    ))
+
+
+class RPS_Lines_Javascript_Counts(RPSBase):  # noqa
+    r""" The number of occurences of the word "javascript" in each line. """
+    SEARCH_TEXT = "javascript"
+    __slots__ = ()
+
+    def _process_line(self, text_slice: TextSlice) -> ScoreType:
+        if len(text_slice.text) == 0:
+            return tuple((text_slice.start, text_slice.end, 0.0))
+
+        score = float(sum(
+            1 for w in text_slice.text.split() if w == self.SEARCH_TEXT
+        ))
+
+        return tuple((text_slice.start, text_slice.end, score))
+
+    def __call__(self, document: Document) -> SignalType:
+        return list(map(self._process_line, document.normalized_lines))
+
+
+class RPS_Lines_Ending_With_Terminal_Punctution_Mark(RPSBase):  # noqa
+    r""" A list of integers indicating whether (1) or not (0) a line ends with
+    a terminal punctuation mark. A terminal punctation mark is defined as
+    one of the following: ".", "!", "?", "”" """
+    TERMINAL_PUNCTUATION_MARKS = (".", "!", "?", "”")
+    __slots__ = ()
+
+    def _process_line(self, text_slice: TextSlice) -> ScoreType:
+        score = text_slice.text.rstrip().endswith(
+            self.TERMINAL_PUNCTUATION_MARKS
+        )
+        score = float(score)
+        return tuple((text_slice.start, text_slice.end, score))
+
+    def __call__(self, document: Document) -> SignalType:
+        return list(map(self._process_line, document.raw_lines))
+
+
+class RPS_Lines_Num_Words(RPSBase):  # noqa
+    r""" The number of words in each line. This is computed based on the
+    normalied text. Normalization is done by lowercasing the text and
+    removing punctuation."""
+    __slots__ = ()
+
+    def _process_line(self, text_slice: TextSlice) -> ScoreType:  # noqa
+        score = len(text_slice.text.split())
+        return tuple((text_slice.start, text_slice.end, score))
+
+    def __call__(self, document: Document) -> SignalType:
+        return list(map(self._process_line, document.normalized_lines))
+
+
+class RPS_Lines_Uppercase_Letter_Fraction(RPSBase):  # noqa
+    r""" The ratio between number of uppercase letters and total number of
+    characters in each line. This is based on the raw text. """
+    __slots__ = ()
+
+    def _process_line(self, text_slice: TextSlice) -> ScoreType:  # noqa
+        if len(text_slice) == 0:
+            return tuple((text_slice.start, text_slice.end, 0.0))
+
+        score = sum(map(str.isupper, text_slice.text)) / len(text_slice)
+        score = round(score, PRECISION)
+        return tuple((text_slice.start, text_slice.end, score))
+
+    def __call__(self, document: Document) -> SignalType:
+        return list(map(self._process_line, document.raw_lines))
+
+
+class RPS_Lines_Numerical_Chars_Fraction(RPSBase):  # noqa
+    r""" The ratio between number of numerical characters and total number of
+    characters in each line. This is based on text after lowercasing and
+    removing punctuation."""
+    __slots__ = ()
+
+    def _process_line(self, text_slice: TextSlice) -> ScoreType:  # noqa
+        if len(text_slice) == 0:
+            return tuple((text_slice.start, text_slice.end, 0.0))
+
+        score = sum(map(str.isnumeric, text_slice.text)) / len(text_slice)
+        score = round(score, PRECISION)
+        return tuple((text_slice.start, text_slice.end, score))
+
+    def __call__(self, document: Document) -> SignalType:
+        return list(map(self._process_line, document.normalized_lines))
+
+
+class RPS_Lines_Start_With_Bulletpoint(RPSBase):  # noqa
+    r""" Whether the lines that start with a bullet point symbol. The
+    following set of unicodes are considered a bullet point:
+    \u2022 (bullet point), \u2023 (triangular bullet point), \u25B6 (black
+    right pointing triangle), \u25C0 (black left pointing triangle),
+    \u25E6 (white bullet point), \u25A0 (black square), \u25A1 (white
+    square), \u25AA (black small square), \u25AB (white small square),
+    \u2013 (en dash)."""
+    BULLET_POINT_SYMBOLS = (
+        "\u2022",  # bullet point
+        "\u2023",  # triangular bullet point
+        "\u25B6",  # black right pointing triangle
+        "\u25C0",  # black left pointing triangle
+        "\u25E6",  # white bullet point
+        "\u25A0",  # black square
+        "\u25A1",  # white square
+        "\u25AA",  # black small square
+        "\u25AB",  # white small square
+        "\u2013",  # en dash
+    )
+
+    __slots__ = ()
+
+    def _process_line(self, text_slice: TextSlice) -> ScoreType:  # noqa
+        score = text_slice.text.lstrip().startswith(self.BULLET_POINT_SYMBOLS)
+        score = float(score)
+        return tuple((text_slice.start, text_slice.end, score))
+
+    def __call__(self, document: Document) -> SignalType:
+        num_lines = len(document.raw_lines)
+
+        if num_lines == 0:
+            return [(0, len(document), None)]
+
+        return list(map(self._process_line, document.raw_lines))

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/quality_signals/natural_language.py

@@ -0,0 +1,197 @@
+from collections import Counter
+import math
+import re
+import sys
+from typing import List, Tuple, Type
+
+from core.constants import PRECISION
+from core.data_types import SignalType
+from core.quality_signals.base import RPSBase
+from core.document import Document
+from utilities.register.registry_utils import *
+
+__all__ = [
+    "register_natural_language_callables",
+    "natural_language_schema"
+]
+
+
+def natural_language_schema() -> List[Tuple[str, Type]]:
+    r""" Returns a list of signal names and their data types """
+    return signal_schema(module=sys.modules[__name__])
+
+
+def register_natural_language_callables() -> List[RPSBase]:
+    r""" Returns a list of signal functions (i.e., RPSBase instances) that
+    are used to extract natural language signals from a document.
+
+    Returns:
+        A list of signal function class instances.
+    """
+    return list(map(
+        lambda cls: cls(),
+        get_callables_from_module(module=sys.modules[__name__])
+    ))
+
+
+class RPS_Doc_Num_Sentences(RPSBase):  # noqa
+    r""" The number of sentences in the content. This is calculated using
+    the regex r'\b[^.!?]+[.!?]*' """
+    SENT_PATTERN = re.compile(r'\b[^.!?]+[.!?]*', flags=re.UNICODE)
+
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        r""" count the number of sentences in the content using regex"""
+        score = float(len(self.SENT_PATTERN.findall(document.raw_content)))
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Word_Count(RPSBase):  # noqa
+    r""" The number of words in the content after normalization. """
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        return [(0, len(document), document.num_normalized_words)]
+
+
+class RPS_Doc_Mean_Word_Length(RPSBase):  # noqa
+    r""" The mean length of words in the content normalization. """
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        if document.num_normalized_words == 0:
+            return [(0, len(document), None)]
+
+        num_chars = float(sum(map(len, document.normalized_words)))
+        score = num_chars / document.num_normalized_words
+        score = round(score, PRECISION)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Symbol_To_Word_Ratio(RPSBase):  # noqa
+    r""" The ratio of symbols to words in the content. This is analogous to
+    the signal used in Gopher. Symbols are defined "#", "...", and "…". """
+    SYMBOLS = ("#", "...", "…")
+
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        num_words = document.num_raw_words
+
+        if num_words == 0:
+            return [(0, len(document), None)]
+
+        # count the number of symbols in the content
+        num_symbols = float(sum(
+            document.raw_content.count(x) for x in self.SYMBOLS
+        ))
+
+        score = num_symbols / num_words
+        score = round(score, PRECISION)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Frac_Lines_End_With_Ellipsis(RPSBase):  # noqa
+    r""" The fraction of lines that end with an ellipsis, where an ellipsis
+    is defined as either "..." or "…". """
+    ELLIPSIS_SYMBOLS = ("...", "…")
+
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        num_lines = len(document.raw_lines)
+
+        if num_lines == 0:
+            return [(0, len(document), None)]
+
+        total_ellipsis_lines = float(sum(
+            text_slice.text.rstrip().endswith(self.ELLIPSIS_SYMBOLS)
+            for text_slice in document.raw_lines
+        ))
+
+        score = total_ellipsis_lines / num_lines
+        score = round(score, PRECISION)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Frac_No_Alph_Words(RPSBase):  # noqa
+    r""" The fraction of words that contain no alphabetical character.
+    This is based on the raw content. """
+    ALPH_REGEX = re.compile(r"[a-zA-Z]")
+
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        num_words = document.num_raw_words
+
+        if num_words == 0:
+            return [(0, len(document), None)]
+
+        num_words_with_alpha = float(sum(
+            int(self.ALPH_REGEX.search(word) is not None)
+            for word in document.raw_words
+        ))
+
+        score = 1.0 - num_words_with_alpha / num_words
+        score = round(score, PRECISION)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Frac_Unique_Words(RPSBase):  # noqa
+    r""" The fraction of unique words in the content. This is also known as
+    the degeneracy of a text sample. Calculated based on the normalized
+    content. """
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        num_words = document.num_normalized_words
+
+        if num_words == 0:
+            return [(0, len(document), None)]
+
+        score = float(len(set(document.normalized_words))) / num_words
+        score = round(score, PRECISION)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Unigram_Entropy(RPSBase):  # noqa
+    r""" The entropy of the unigram distribution of the
+    content. This measures the diversity of the content and is computed
+    using sum(-x / total * log(x / total)) where the sum is taken over
+    over counts of unique words in the noramlized (punctuation removed,
+    lowercased) content."""
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        if len(document.normalized_words) == 0:
+            return [(0, len(document), None)]
+
+        # count the number of times each word appears in the content
+        counter = Counter(document.normalized_words)
+
+        # calculate the entropy of the unigram distribution
+        total = sum(counter.values())
+        entropy = sum(map(
+            lambda x: -x / total * math.log(x / total) if x > 0 else 0.0,
+            counter.values()
+        ))
+
+        score = round(entropy, PRECISION)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Frac_All_Caps_Words(RPSBase):  # noqa
+    r""" The fraction of words in the content that only conist of uppercase
+    letters. This is based on the raw content."""
+    __slots__ = ()
+
+    def __call__(self, document: Document) -> SignalType:
+        num_words = document.num_raw_words
+
+        if num_words == 0:
+            return [(0, len(document), None)]
+
+        score = float(sum(map(str.isupper, document.raw_words))) / num_words
+        score = round(score, PRECISION)
+        return [(0, len(document), score)]

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/quality_signals/repetitions.py

@@ -0,0 +1,205 @@
+from collections import Counter
+import numpy as np
+import sys
+from typing import List, Tuple, Type
+
+from core.constants import PRECISION
+from core.quality_signals.base import RPSBase
+from core.document import Document
+from core.data_types import SignalType
+from utilities.register.registry_utils import *
+from utilities.text import form_ngrams
+
+__all__ = [
+    "register_repetitions_callables",
+    "repetitions_schema"
+]
+
+
+def repetitions_schema() -> List[Tuple[str, Type]]:
+    r""" Returns a list of signal names and their data types """
+    return signal_schema(module=sys.modules[__name__])
+
+
+def register_repetitions_callables() -> List[RPSBase]:
+    r""" Returns a list of signal functions (i.e., RPSBase instances) that
+    are used to extract repetition related signals from a document.
+
+    Returns:
+        A list of signal function class instances.
+    """
+    return list(map(
+        lambda cls: cls(),
+        get_callables_from_module(module=sys.modules[__name__])
+    ))
+
+
+class Base_RPS_Frac_Chars_In_Top_NGram(RPSBase):  # noqa
+    r""" Base class for calculating the fraction of characters in the
+    top N-gram. This operates on the lower-cased, punctation removed
+    content."""
+    NGRAM_SIZE: int = None
+
+    __slots__ = []
+
+    def __call__(self, document: Document) -> SignalType:
+        if self.NGRAM_SIZE is None:
+            raise NotImplementedError(
+                "NGRAM_SIZE must be set in the subclass"
+            )
+
+        # get the most common ngram
+        most_common_ngram = Counter(
+            # fetch the ngrams from the document if they exist, otherwise
+            # compute them
+            getattr(document, f"norm_{self.NGRAM_SIZE}grams", None)
+            or
+            form_ngrams(iter(document.normalized_words), self.NGRAM_SIZE)
+        ).most_common(1)
+
+        if len(most_common_ngram) == 0:
+            return [(0, len(document), 0.0)]
+
+        ngram, count = most_common_ngram[0]
+
+        if count <= 1:
+            return [(0, len(document), 0.0)]
+
+        total_chars = sum(len(w) for w in document.normalized_words)
+        score = sum(len(w) for w in ngram) * count / total_chars
+        score = round(score, PRECISION)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Frac_Chars_Top_2gram(Base_RPS_Frac_Chars_In_Top_NGram):  # noqa
+    r""" The fraction of characters in the top word Bigram. Operates on the
+    lower-cased, punctation removed content."""
+    NGRAM_SIZE = 2
+    __slots__ = []
+
+
+class RPS_Doc_Frac_Chars_Top_3gram(Base_RPS_Frac_Chars_In_Top_NGram):  # noqa
+    r""" The fraction of characters in the top word Trigram. Operates on the
+    lower-cased, punctation removed content."""
+    NGRAM_SIZE = 3
+    __slots__ = []
+
+
+class RPS_Doc_Frac_Chars_Top_4gram(Base_RPS_Frac_Chars_In_Top_NGram):  # noqa
+    r""" The fraction of characters in the top word 4gram. Operates on the
+    lower-cased, punctation removed content."""
+    NGRAM_SIZE = 4
+    __slots__ = []
+
+
+class Base_RPS_Frac_Chars_In_Dupe_NGrams(RPSBase):  # noqa
+    r""" Base class for calculating the fraction of characters in
+    duplicate word N-grams. This operates on the lower-cased, punctation
+    removed content. The function also ensures that characters in overlapping
+    ngrams are only counted once."""
+    NGRAM_SIZE: int = None
+    __slots__ = []
+
+    def __call__(self, document: Document) -> SignalType:
+        if self.NGRAM_SIZE is None:
+            raise NotImplementedError(
+                "NGRAM_SIZE must be set in the subclass"
+            )
+
+        if len(document.normalized_words) < self.NGRAM_SIZE:
+            return [(0, len(document), 0.0)]
+
+        # fetch the ngrams from the document if they exist, otherwise
+        # compute them
+        doc_n_grams = (
+                getattr(document, f"norm_{self.NGRAM_SIZE}grams", None)
+                or
+                tuple(form_ngrams(
+                    iter(document.normalized_words), self.NGRAM_SIZE
+                ))
+        )
+
+        # keep only ngrams which occur at least twice
+        ngram_dupes = {
+            ngram for ngram, count in Counter(doc_n_grams).items() if count > 1
+        }
+
+        duplicated_grams = np.zeros(len(document.normalized_words), dtype=int)
+
+        i = 0
+        for ngram in doc_n_grams:
+            if ngram in ngram_dupes:
+                duplicated_grams[i: i + self.NGRAM_SIZE] = 1
+
+            i += 1
+
+        word_lengths = np.array(list(map(len, document.normalized_words)))
+        chars_duped = np.sum(word_lengths * duplicated_grams)
+        total_chars = np.sum(word_lengths)
+
+        if total_chars == 0:
+            return [(0, len(document), 0.0)]
+
+        score = float(chars_duped / total_chars)
+        score = round(score, PRECISION)
+        return [(0, len(document), score)]
+
+
+class RPS_Doc_Frac_Chars_Dupe_5Grams(  # noqa
+    Base_RPS_Frac_Chars_In_Dupe_NGrams
+):
+    r""" The fraction of characters in duplicate word 5grams. This operates on
+    the lower-cased, punctation removed content. It is also ensured that
+    characters in overlapping ngrams are only counted once. """
+    NGRAM_SIZE = 5
+    __slots__ = []
+
+
+class RPS_Doc_Frac_Chars_Dupe_6Grams(  # noqa
+    Base_RPS_Frac_Chars_In_Dupe_NGrams
+):
+    r""" The fraction of characters in duplicate word 6grams. This operates on
+    the lower-cased, punctation removed content. It is also ensured that
+    characters in overlapping ngrams are only counted once. """
+    NGRAM_SIZE = 6
+    __slots__ = []
+
+
+class RPS_Doc_Frac_Chars_Dupe_7Grams(  # noqa
+    Base_RPS_Frac_Chars_In_Dupe_NGrams
+):
+    r""" The fraction of characters in duplicate word 7grams. This operates on
+    the lower-cased, punctation removed content. It is also ensured that
+    characters in overlapping ngrams are only counted once. """
+    NGRAM_SIZE = 7
+    __slots__ = []
+
+
+class RPS_Doc_Frac_Chars_Dupe_8Grams(  # noqa
+    Base_RPS_Frac_Chars_In_Dupe_NGrams
+):
+    r""" The fraction of characters in duplicate word 8grams. This operates on
+    the lower-cased, punctation removed content. It is also ensured that
+    characters in overlapping ngrams are only counted once. """
+    NGRAM_SIZE = 8
+    __slots__ = []
+
+
+class RPS_Doc_Frac_Chars_Dupe_9Grams(  # noqa
+    Base_RPS_Frac_Chars_In_Dupe_NGrams
+):
+    r""" The fraction of characters in duplicate word 9grams. This operates on
+    the lower-cased, punctation removed content. It is also ensured that
+    characters in overlapping ngrams are only counted once. """
+    NGRAM_SIZE = 9
+    __slots__ = []
+
+
+class RPS_Doc_Frac_Chars_Dupe_10Grams(  # noqa
+    Base_RPS_Frac_Chars_In_Dupe_NGrams
+):
+    r""" The fraction of characters in duplicate word 10grams. This operates on
+    the lower-cased, punctation removed content. It is also ensured that
+    characters in overlapping ngrams are only counted once. """
+    NGRAM_SIZE = 10
+    __slots__ = []

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/quality_signals/utils/classifiers.py

@@ -0,0 +1,15 @@
+from core.document import Document
+
+
+def preprocess_quality_classifier(document: Document):
+    r""" Preprocesses a document for quality classification. This function
+    removes all newlines and trailing whitespaces from the document.
+
+    Args:
+        document: A document.
+
+    Returns:
+        A string.
+    """
+    # remove newlines and trailing and leading whitespaces
+    return " ".join(document.raw_content.splitlines()).strip()

cc-multilingual-main/dedup/RedPajama-Data/app/src/core/quality_signals/utils/content.py

@@ -0,0 +1,39 @@
+import json
+from pathlib import Path
+from typing import Dict, Set
+
+_DEFAULT_LANGS = ("en", "fr", "it", "es", "de")
+
+
+def load_bad_urls_index(bad_urls_dir: Path) -> Dict[str, int]:
+    with open(bad_urls_dir / "domain_to_category_id.json", "r") as f:
+        domain_to_category_id = json.load(f)
+    return domain_to_category_id
+
+
+def load_bad_words(bad_words_dir: Path, lang: str) -> Set[str]:
+    r""" load the LDNOOBW word list for a given language
+
+    Source:
+        https://github.com/LDNOOBW/List-of-Dirty-Naughty-Obscene-and-Otherwise-Bad-Words
+
+    Args:
+        bad_words_dir (Path): The path to the resources directory where the
+            list is stored
+        lang (str): The language for which to fetch the word list
+
+    Returns:
+        A set of words
+    """
+    if lang not in _DEFAULT_LANGS:
+        return set()
+
+    ldnoobw_fp = bad_words_dir / f"{lang}.txt"
+
+    if not ldnoobw_fp.exists():
+        raise FileNotFoundError(f"LDNOOBW word list {ldnoobw_fp} not found!")
+
+    with open(ldnoobw_fp, 'r') as f:
+        data = set(ln.strip() for ln in f.readlines())
+
+    return data