init

.gitignore

@@ -0,0 +1,2 @@
+super_tweeteval
+data

timelm_preprocessor.py

@@ -0,0 +1,123 @@
+"""
+Removes near-duplicates and tweets from top pct. of users.
+
+original -> https://github.com/cardiffnlp/timelms/blob/main/scripts/preprocess.py
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --src SRC             Path to set of input tweets (.jl).
+  --out OUT             Path to output from preprocessing (.jl).
+  --blacklist_pct BLACKLIST_PCT
+                        Percent of most frequent users to ignore.
+Example:
+python preprocess.py --src data/tweets-2020-Q3.jl --out dataset/tweets/tweets-2020-Q3.jl
+"""
+
+import argparse
+import json
+import logging
+import os
+import string
+import re
+from collections import Counter
+
+from datasketch import MinHash, LeanMinHash
+import xxhash
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
+re_url = re.compile(r'https?:\/\/[\w\.\/\?\=\d&#%_:/-]+')
+re_user = re.compile(r'@\w+')
+with open('verified_users.v091122.txt') as f:
+    verified_users = set([f"@{i}" for i in f.read().split('\n') if len(i)])
+
+
+def clean_text(text):
+    text = text.replace('\n', ' ').replace('\r', ' ').replace('\t', ' ')
+    text = re_url.sub('{URL}', text)
+    users = re_user.findall(text)
+    for user in users:
+        if user not in verified_users:
+            text = text.replace(user, '@user')
+    return text
+
+
+def hash_tweet(target_tweet, num_perm=16):
+    def normalize_text(text):
+        text = text.translate(str.maketrans('', '', string.punctuation))  # remove punctuation
+        text = text.lower()
+        return text
+
+    def minhash(seq):
+        # https://skeptric.com/minhash/
+        m = MinHash(num_perm=num_perm, hashfunc=xxhash.xxh64_intdigest)
+        for s in seq:
+            m.update(s.encode('utf8'))
+        return LeanMinHash(m)
+
+    tokens = normalize_text(target_tweet['text']).split()  # whitespace tokenization
+    return minhash(tokens)
+
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser(description='Removes near-duplicates and tweets from top pct. of users.')
+    parser.add_argument('--src', type=str, required=True, help='Path to set of input tweets (.jl).')
+    parser.add_argument('--out', type=str, required=True, help='Path to output from preprocessing (.jl).')
+    parser.add_argument('--blacklist_pct', type=float, required=False, default=0.01,
+                        help='Percent of most frequent users to ignore.')
+    args = parser.parse_args()
+    os.makedirs(args.out, exist_ok=True)
+
+    logging.info('1st pass - Collecting username counts ...')
+    n_input_tweets = 0
+    user_counter = Counter()
+    with open(args.src) as in_tweets_f:
+        for idx, jl_str in enumerate(in_tweets_f):
+            if idx % 1e6 == 0:
+                logging.info('1st pass - at idx %d' % idx)
+            tweet = json.loads(jl_str)
+            user_counter[tweet['username']] += 1
+            n_input_tweets += 1
+
+    logging.info('1st pass - Completed, found %d tweets' % n_input_tweets)
+    logging.info('1st pass - Found %d users' % len(user_counter.keys()))
+
+    top_users = [user for user, _ in user_counter.most_common()]
+    n_blacklisted_users = int(len(top_users) * args.blacklist_pct)
+    blacklisted_users = set(top_users[:n_blacklisted_users])
+    n_users = len(user_counter.keys())
+    pct_blacklisted_users = round((n_blacklisted_users / n_users) * 100, 2)
+    n_blacklisted_tweets = sum([user_counter[u] for u in blacklisted_users])
+    pct_blacklisted_tweets = round((n_blacklisted_tweets / sum(user_counter.values())) * 100, 2)
+    logging.info(
+        f"1st pass - Blacklisted {len(blacklisted_users)} users ({pct_blacklisted_users}%), "
+        f"ignoring {n_blacklisted_tweets} tweets ({pct_blacklisted_tweets}%)"
+    )
+
+    logging.info('2nd pass - Hashing and writing valid tweets ...')
+    written_hashes = set()
+    n_written = 0
+    n_ignored_by_user = 0
+    n_ignored_by_hash = 0
+    with open(args.src) as in_tweets_f:
+        with open(args.out, 'w') as out_tweets_f:
+            for idx, jl_str in enumerate(in_tweets_f):
+                if idx % 1e5 == 0:
+                    logging.info('2nd pass - at idx %d' % idx)
+                tweet = json.loads(jl_str)
+                tweet['text'] = clean_text(tweet['text'])
+                tweet_hash = hash_tweet(tweet)
+                if tweet['username'] in blacklisted_users:
+                    n_ignored_by_user += 1
+                elif tweet_hash in written_hashes:
+                    n_ignored_by_hash += 1
+                else:
+                    out_tweets_f.write(json.dumps(tweet) + '\n')
+                    n_written += 1
+                    written_hashes.add(tweet_hash)
+    logging.info(f"2nd pass - Completed, wrote {n_written} tweets.")
+    if n_ignored_by_user > 0:
+        logging.info(f"\tignored {n_ignored_by_user} by user blacklist")
+    if n_ignored_by_hash > 0:
+        logging.info(f"\tignored {n_ignored_by_hash} by hash collision")
+    logging.info("Done")

util.py

@@ -0,0 +1,13 @@
+import re
+
+
+URL_RE = re.compile(r"https?:\/\/[\w\.\/\?\=\d&#%_:/-]+")
+HANDLE_RE = re.compile(r"@\w+")
+with open("verified_users.v091122.txt") as f:
+    USER = set(i for i in f.read().split("\n") if len(i))
+
+def process_url(text: str) -> str:
+    return URL_RE.sub("{URL}", text)
+
+def process_username(text: str) -> str:
+    return HANDLE_RE.sub("[URL]", text)