Datasets:

cardiffnlp
/

tweet_topic_single

@@ -14,99 +14,18 @@ task_ids:
 pretty_name: TweetTopicSingle
 ---
-# Dataset Card for "cardiffnlp/tweet_topic_single"
 ## Dataset Description
-- **Paper:** [https://arxiv.org/abs/2209.09824](https://arxiv.org/abs/2209.09824)
 - **Dataset:** Tweet Topic Dataset
 - **Domain:** Twitter
 - **Number of Class:** 6
 ### Dataset Summary
-This is the official repository of TweetTopic (["Twitter Topic Classification
-, COLING main conference 2022"](https://arxiv.org/abs/2209.09824)), a topic classification dataset on Twitter with 6 labels.
-Each instance of TweetTopic comes with a timestamp which distributes from September 2019 to August 2021.
-See [cardiffnlp/tweet_topic_multi](https://huggingface.co/datasets/cardiffnlp/tweet_topic_multi) for multi label version of TweetTopic.
-The tweet collection used in TweetTopic is same as what used in [TweetNER7](https://huggingface.co/datasets/tner/tweetner7).
-The dataset is integrated in [TweetNLP](https://tweetnlp.org/) too.
-### Preprocessing
-We pre-process tweets before the annotation to normalize some artifacts, converting URLs into a special token `{{URL}}` and non-verified usernames into `{{USERNAME}}`.
-For verified usernames, we replace its display name (or account name) with symbols `{@}`.
-For example, a tweet
-```
-Get the all-analog Classic Vinyl Edition
-of "Takin' Off" Album from @herbiehancock
-via @bluenoterecords link below:
-http://bluenote.lnk.to/AlbumOfTheWeek
-```
-is transformed into the following text.
-```
-Get the all-analog Classic Vinyl Edition
-of "Takin' Off" Album from {@herbiehancock@}
-via {@bluenoterecords@} link below: {{URL}}
-```
-A simple function to format tweet follows below.
-```python
-import re
-from urlextract import URLExtract
-extractor = URLExtract()
-def format_tweet(tweet):
-    # mask web urls
-    urls = extractor.find_urls(tweet)
-    for url in urls:
-        tweet = tweet.replace(url, "{{URL}}")
-    # format twitter account
-    tweet = re.sub(r"\b(\s*)(@[\S]+)\b", r'\1{\2@}', tweet)
-    return tweet
-target = """Get the all-analog Classic Vinyl Edition of "Takin' Off" Album from @herbiehancock via @bluenoterecords link below: http://bluenote.lnk.to/AlbumOfTheWeek"""
-target_format = format_tweet(target)
-print(target_format)
-'Get the all-analog Classic Vinyl Edition of "Takin\' Off" Album from {@herbiehancock@} via {@bluenoterecords@} link below: {{URL}}'
-```
-### Data Splits
-| split                   | number of texts | description |
-|:------------------------|-----:|------:|
-| test_2020               |  376 | test dataset from September 2019 to August 2020 |
-| test_2021               | 1693 | test dataset from September 2020 to August 2021 |
-| train_2020              | 2858 | training dataset from September 2019 to August 2020 |
-| train_2021              | 1516 | training dataset from September 2020 to August 2021 |
-| train_all               | 4374 | combined training dataset of `train_2020` and `train_2021` |
-| validation_2020         |  352 | validation dataset from September 2019 to August 2020 |
-| validation_2021         |  189 | validation dataset from September 2020 to August 2021 |
-| train_random            | 2830 | randomly sampled training dataset with the same size as `train_2020` from `train_all` |
-| validation_random       |  354 | randomly sampled training dataset with the same size as `validation_2020` from `validation_all` |
-| test_coling2022_random  | 3399 | random split used in the COLING 2022 paper |
-| train_coling2022_random | 3598 | random split used in the COLING 2022 paper |
-| test_coling2022         | 3399 | temporal split used in the COLING 2022 paper |
-| train_coling2022        | 3598 | temporal split used in the COLING 2022 paper |
-For the temporal-shift setting, model should be trained on `train_2020` with `validation_2020` and evaluate on `test_2021`.
-In general, model would be trained on `train_all`, the most representative training set with `validation_2021` and evaluate on `test_2021`.
-**IMPORTANT NOTE:** To get a result that is comparable with the results of the COLING 2022 Tweet Topic paper, please use `train_coling2022` and `test_coling2022` for temporal-shift, and `train_coling2022_random` and `test_coling2022_random` fir random split (the coling2022 split does not have validation set).
-### Models
-| model                                                                                                                                                       | training data     |       F1 |   F1 (macro) |   Accuracy |
-|:------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------|---------:|-------------:|-----------:|
-| [cardiffnlp/roberta-large-tweet-topic-single-all](https://huggingface.co/cardiffnlp/roberta-large-tweet-topic-single-all)                                   | all (2020 + 2021) | 0.896043 |     0.800061 |   0.896043 |
-| [cardiffnlp/roberta-base-tweet-topic-single-all](https://huggingface.co/cardiffnlp/roberta-base-tweet-topic-single-all)                                     | all (2020 + 2021) | 0.887773 |     0.79793  |   0.887773 |
-| [cardiffnlp/twitter-roberta-base-2019-90m-tweet-topic-single-all](https://huggingface.co/cardiffnlp/twitter-roberta-base-2019-90m-tweet-topic-single-all)   | all (2020 + 2021) | 0.892499 |     0.774494 |   0.892499 |
-| [cardiffnlp/twitter-roberta-base-dec2020-tweet-topic-single-all](https://huggingface.co/cardiffnlp/twitter-roberta-base-dec2020-tweet-topic-single-all)     | all (2020 + 2021) | 0.890136 |     0.776025 |   0.890136 |
-| [cardiffnlp/twitter-roberta-base-dec2021-tweet-topic-single-all](https://huggingface.co/cardiffnlp/twitter-roberta-base-dec2021-tweet-topic-single-all)     | all (2020 + 2021) | 0.894861 |     0.800952 |   0.894861 |
-| [cardiffnlp/roberta-large-tweet-topic-single-2020](https://huggingface.co/cardiffnlp/roberta-large-tweet-topic-single-2020)                                 | 2020 only         | 0.878913 |     0.70565  |   0.878913 |
-| [cardiffnlp/roberta-base-tweet-topic-single-2020](https://huggingface.co/cardiffnlp/roberta-base-tweet-topic-single-2020)                                   | 2020 only         | 0.868281 |     0.729667 |   0.868281 |
-| [cardiffnlp/twitter-roberta-base-2019-90m-tweet-topic-single-2020](https://huggingface.co/cardiffnlp/twitter-roberta-base-2019-90m-tweet-topic-single-2020) | 2020 only         | 0.882457 |     0.740187 |   0.882457 |
-| [cardiffnlp/twitter-roberta-base-dec2020-tweet-topic-single-2020](https://huggingface.co/cardiffnlp/twitter-roberta-base-dec2020-tweet-topic-single-2020)   | 2020 only         | 0.87596  |     0.746275 |   0.87596  |
-| [cardiffnlp/twitter-roberta-base-dec2021-tweet-topic-single-2020](https://huggingface.co/cardiffnlp/twitter-roberta-base-dec2021-tweet-topic-single-2020)   | 2020 only         | 0.877732 |     0.746119 |   0.877732 |
-Model fine-tuning script can be found [here](https://huggingface.co/datasets/cardiffnlp/tweet_topic_single/blob/main/lm_finetuning.py).
 ## Dataset Structure
@@ -136,21 +55,29 @@ The label2id dictionary can be found at [here](https://huggingface.co/datasets/t
 }
 ```
 ### Citation Information
 ```
-@inproceedings{dimosthenis-etal-2022-twitter,
-    title = "{T}witter {T}opic {C}lassification",
-    author = "Antypas, Dimosthenis  and
-    Ushio, Asahi  and
-    Camacho-Collados, Jose  and
-    Neves, Leonardo  and
-    Silva, Vitor  and
-    Barbieri, Francesco",
-    booktitle = "Proceedings of the 29th International Conference on Computational Linguistics",
-    month = oct,
-    year = "2022",
-    address = "Gyeongju, Republic of Korea",
-    publisher = "International Committee on Computational Linguistics"
-}
 ```

 pretty_name: TweetTopicSingle
 ---
+# Dataset Card for "cardiff_nlp/tweet_topic_single"
 ## Dataset Description
+- **Paper:** TBA
 - **Dataset:** Tweet Topic Dataset
 - **Domain:** Twitter
 - **Number of Class:** 6
 ### Dataset Summary
+Topic classification dataset on Twitter with single label per tweet.
 ## Dataset Structure
 }
 ```
+### Data Splits
+| split                     | number of texts |
+|:--------------------------|-----:|
+| test                      | 1679 |
+| train                     | 1505 |
+| validation                |  188 |
+| temporal_2020_test        |  573 |
+| temporal_2021_test        | 1679 |
+| temporal_2020_train       | 4585 |
+| temporal_2021_train       | 1505 |
+| temporal_2020_validation  |  573 |
+| temporal_2021_validation  |  188 |
+| random_train              | 4564 |
+| random_validation         |  573 |
+| coling2022_random_test    | 5536 |
+| coling2022_random_train   | 5731 |
+| coling2022_temporal_test  | 5536 |
+| coling2022_temporal_train | 5731 |
 ### Citation Information
 ```
+TBA
 ```

get_model_list.py DELETED Viewed

@@ -1,47 +0,0 @@
-import json
-import os
-import requests
-import pandas as pd
-def download(filename, url):
-    try:
-        with open(filename) as f:
-            json.load(f)
-    except Exception:
-        os.makedirs(os.path.dirname(filename), exist_ok=True)
-        with open(filename, "wb") as f:
-            r = requests.get(url)
-            f.write(r.content)
-    with open(filename) as f:
-        tmp = json.load(f)
-    return tmp
-models = [
-  "cardiffnlp/roberta-large-tweet-topic-single-all",
-  "cardiffnlp/roberta-base-tweet-topic-single-all",
-  "cardiffnlp/twitter-roberta-base-2019-90m-tweet-topic-single-all",
-  "cardiffnlp/twitter-roberta-base-dec2020-tweet-topic-single-all",
-  "cardiffnlp/twitter-roberta-base-dec2021-tweet-topic-single-all",
-  "cardiffnlp/roberta-large-tweet-topic-single-2020",
-  "cardiffnlp/roberta-base-tweet-topic-single-2020",
-  "cardiffnlp/twitter-roberta-base-2019-90m-tweet-topic-single-2020",
-  "cardiffnlp/twitter-roberta-base-dec2020-tweet-topic-single-2020",
-  "cardiffnlp/twitter-roberta-base-dec2021-tweet-topic-single-2020"
-]
-os.makedirs("metric_files", exist_ok=True)
-metrics = []
-for i in models:
-    model_type = "all (2020 + 2021)" if i.endswith("all") else "2020 only"
-    url = f"https://huggingface.co/{i}/raw/main/metric_summary.json"
-    model_url = f"https://huggingface.co/{i}"
-    metric = download(f"metric_files/{os.path.basename(i)}.json", url)
-    metrics.append({"model": f"[{i}]({model_url})", "training data": model_type, "F1": metric["test/eval_f1"], "F1 (macro)": metric["test/eval_f1_macro"], "Accuracy": metric["test/eval_accuracy"]})
-df = pd.DataFrame(metrics)
-print(df.to_markdown(index=False))

lm_finetuning.py DELETED Viewed

@@ -1,226 +0,0 @@
-'''
-wandb offline
-export WANDB_DISABLED='true'
-export RAY_RESULTS='ray_results'
-python lm_finetuning.py -m "roberta-large" -o "ckpt/2021/roberta-large" --push-to-hub --hf-organization "cardiffnlp" -a "roberta-large-tweet-topic-single-all" --split-train "train_all" --split-valid "validation_2021" --split-test "test_2021"
-python lm_finetuning.py -m "roberta-large" -o "ckpt/2020/roberta-large" --push-to-hub --hf-organization "cardiffnlp" -a "roberta-large-tweet-topic-single-2020" --split-train "train_2020" --split-valid "validation_2020" --split-test "test_2021"
-python lm_finetuning.py -m "roberta-base" -o "ckpt/2021/roberta_base" --push-to-hub --hf-organization "cardiffnlp" -a "roberta-base-tweet-topic-single-all" --split-train "train_all" --split-valid "validation_2021" --split-test "test_2021"
-python lm_finetuning.py -m "roberta-base" -o "ckpt/2020/roberta_base" --push-to-hub --hf-organization "cardiffnlp" -a "roberta-base-tweet-topic-single-2020" --split-train "train_2020" --split-valid "validation_2020" --split-test "test_2021"
-python lm_finetuning.py -m "cardiffnlp/twitter-roberta-base-2019-90m" -o "ckpt/2021/twitter-roberta-base-2019-90m" --push-to-hub --hf-organization "cardiffnlp" -a "twitter-roberta-base-2019-90m-tweet-topic-single-all" --split-train "train_all" --split-valid "validation_2021" --split-test "test_2021"
-python lm_finetuning.py -m "cardiffnlp/twitter-roberta-base-2019-90m" -o "ckpt/2020/twitter-roberta-base-2019-90m" --push-to-hub --hf-organization "cardiffnlp" -a "twitter-roberta-base-2019-90m-tweet-topic-single-2020" --split-train "train_2020" --split-valid "validation_2020" --split-test "test_2021"
-python lm_finetuning.py -m "cardiffnlp/twitter-roberta-base-dec2020" -o "ckpt/2021/twitter-roberta-base-dec2020" --push-to-hub --hf-organization "cardiffnlp" -a "twitter-roberta-base-dec2020-tweet-topic-single-all" --split-train "train_all" --split-valid "validation_2021" --split-test "test_2021"
-python lm_finetuning.py -m "cardiffnlp/twitter-roberta-base-dec2020" -o "ckpt/2020/twitter-roberta-base-dec2020" --push-to-hub --hf-organization "cardiffnlp" -a "twitter-roberta-base-dec2020-tweet-topic-single-2020" --split-train "train_2020" --split-valid "validation_2020" --split-test "test_2021"
-python lm_finetuning.py -m "cardiffnlp/twitter-roberta-base-dec2021" -o "ckpt/2021/twitter-roberta-base-dec2021" --push-to-hub --hf-organization "cardiffnlp" -a "twitter-roberta-base-dec2021-tweet-topic-single-all" --split-train "train_all" --split-valid "validation_2021" --split-test "test_2021"
-python lm_finetuning.py -m "cardiffnlp/twitter-roberta-base-dec2021" -o "ckpt/2020/twitter-roberta-base-dec2021" --push-to-hub --hf-organization "cardiffnlp" -a "twitter-roberta-base-dec2021-tweet-topic-single-2020" --split-train "train_2020" --split-valid "validation_2020" --split-test "test_2021"
-'''
-import argparse
-import json
-import logging
-import os
-import shutil
-import urllib.request
-import multiprocessing
-from os.path import join as pj
-import torch
-import numpy as np
-from huggingface_hub import create_repo
-from datasets import load_dataset, load_metric
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
-from ray import tune
-from readme import get_readme
-logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s', level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S')
-PARALLEL = bool(int(os.getenv("PARALLEL", 1)))
-RAY_RESULTS = os.getenv("RAY_RESULTS", "ray_results")
-LABEL2ID = {
-        "arts_&_culture": 0,
-        "business_&_entrepreneurs": 1,
-        "pop_culture": 2,
-        "daily_life": 3,
-        "sports_&_gaming": 4,
-        "science_&_technology": 5
-    }
-ID2LABEL = {v: k for k, v in LABEL2ID.items()}
-def internet_connection(host='http://google.com'):
-    try:
-        urllib.request.urlopen(host)
-        return True
-    except:
-        return False
-def get_metrics():
-    metric_accuracy = load_metric("accuracy")
-    metric_f1 = load_metric("f1")
-    def compute_metric_search(eval_pred):
-        logits, labels = eval_pred
-        predictions = np.argmax(logits, axis=-1)
-        return metric_f1.compute(predictions=predictions, references=labels, average='micro')
-    def compute_metric_all(eval_pred):
-        logits, labels = eval_pred
-        predictions = np.argmax(logits, axis=-1)
-        return {
-            'f1': metric_f1.compute(predictions=predictions, references=labels, average='micro')['f1'],
-            'f1_macro': metric_f1.compute(predictions=predictions, references=labels, average='macro')['f1'],
-            'accuracy': metric_accuracy.compute(predictions=predictions, references=labels)['accuracy']
-        }
-    return compute_metric_search, compute_metric_all
-def main():
-    parser = argparse.ArgumentParser(description='Fine-tuning language model.')
-    parser.add_argument('-m', '--model', help='transformer LM', default='roberta-base', type=str)
-    parser.add_argument('-d', '--dataset', help='', default='cardiffnlp/tweet_topic_single', type=str)
-    parser.add_argument('--split-train', help='', required=True, type=str)
-    parser.add_argument('--split-validation', help='', required=True, type=str)
-    parser.add_argument('--split-test', help='', required=True, type=str)
-    parser.add_argument('-l', '--seq-length', help='', default=128, type=int)
-    parser.add_argument('--random-seed', help='', default=42, type=int)
-    parser.add_argument('--eval-step', help='', default=50, type=int)
-    parser.add_argument('-o', '--output-dir', help='Directory to output', default='ckpt_tmp', type=str)
-    parser.add_argument('-t', '--n-trials', default=10, type=int)
-    parser.add_argument('--push-to-hub', action='store_true')
-    parser.add_argument('--use-auth-token', action='store_true')
-    parser.add_argument('--hf-organization', default=None, type=str)
-    parser.add_argument('-a', '--model-alias', help='', default=None, type=str)
-    parser.add_argument('--summary-file', default='metric_summary.json', type=str)
-    parser.add_argument('--skip-train', action='store_true')
-    parser.add_argument('--skip-eval', action='store_true')
-    opt = parser.parse_args()
-    assert opt.summary_file.endswith('.json'), f'`--summary-file` should be a json file {opt.summary_file}'
-    # setup data
-    dataset = load_dataset(opt.dataset)
-    network = internet_connection()
-    # setup model
-    tokenizer = AutoTokenizer.from_pretrained(opt.model, local_files_only=not network)
-    model = AutoModelForSequenceClassification.from_pretrained(
-        opt.model,
-        num_labels=6,
-        local_files_only=not network,
-        id2label=ID2LABEL,
-        label2id=LABEL2ID
-        )
-    tokenized_datasets = dataset.map(
-        lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=opt.seq_length),
-        batched=True)
-    # setup metrics
-    compute_metric_search, compute_metric_all = get_metrics()
-    if not opt.skip_train:
-        # setup trainer
-        trainer = Trainer(
-            model=model,
-            args=TrainingArguments(
-                output_dir=opt.output_dir,
-                evaluation_strategy="steps",
-                eval_steps=opt.eval_step,
-                seed=opt.random_seed
-            ),
-            train_dataset=tokenized_datasets[opt.split_train],
-            eval_dataset=tokenized_datasets[opt.split_validation],
-            compute_metrics=compute_metric_search,
-            model_init=lambda x: AutoModelForSequenceClassification.from_pretrained(
-                opt.model,
-                num_labels=6,
-                local_files_only=not network,
-                return_dict=True,
-                id2label=ID2LABEL,
-                label2id=LABEL2ID
-            )
-        )
-        # parameter search
-        if PARALLEL:
-            best_run = trainer.hyperparameter_search(
-                hp_space=lambda x: {
-                    "learning_rate": tune.loguniform(1e-6, 1e-4),
-                    "num_train_epochs": tune.choice(list(range(1, 6))),
-                    "per_device_train_batch_size": tune.choice([4, 8, 16, 32, 64]),
-                },
-                local_dir=RAY_RESULTS, direction="maximize", backend="ray", n_trials=opt.n_trials,
-                resources_per_trial={'cpu': multiprocessing.cpu_count(), "gpu": torch.cuda.device_count()},
-            )
-        else:
-            best_run = trainer.hyperparameter_search(
-                hp_space=lambda x: {
-                    "learning_rate": tune.loguniform(1e-6, 1e-4),
-                    "num_train_epochs": tune.choice(list(range(1, 6))),
-                    "per_device_train_batch_size": tune.choice([4, 8, 16, 32, 64]),
-                },
-                local_dir=RAY_RESULTS, direction="maximize", backend="ray", n_trials=opt.n_trials
-            )
-        # finetuning
-        for n, v in best_run.hyperparameters.items():
-            setattr(trainer.args, n, v)
-        trainer.train()
-        trainer.save_model(pj(opt.output_dir, 'best_model'))
-        best_model_path = pj(opt.output_dir, 'best_model')
-    else:
-        best_model_path = pj(opt.output_dir, 'best_model')
-    # evaluation
-    model = AutoModelForSequenceClassification.from_pretrained(
-        best_model_path,
-        num_labels=6,
-        local_files_only=not network,
-        id2label=ID2LABEL,
-        label2id=LABEL2ID
-    )
-    trainer = Trainer(
-        model=model,
-        args=TrainingArguments(
-            output_dir=opt.output_dir,
-            evaluation_strategy="no",
-            seed=opt.random_seed
-        ),
-        train_dataset=tokenized_datasets[opt.split_train],
-        eval_dataset=tokenized_datasets[opt.split_test],
-        compute_metrics=compute_metric_all,
-    )
-    summary_file = pj(opt.output_dir, opt.summary_file)
-    if not opt.skip_eval:
-        result = {f'test/{k}': v for k, v in trainer.evaluate().items()}
-        logging.info(json.dumps(result, indent=4))
-        with open(summary_file, 'w') as f:
-            json.dump(result, f)
-    if opt.push_to_hub:
-        assert opt.hf_organization is not None, f'specify hf organization `--hf-organization`'
-        assert opt.model_alias is not None, f'specify hf organization `--model-alias`'
-        url = create_repo(opt.model_alias, organization=opt.hf_organization, exist_ok=True)
-        # if not opt.skip_train:
-        args = {"use_auth_token": opt.use_auth_token, "repo_url": url, "organization": opt.hf_organization}
-        trainer.model.push_to_hub(opt.model_alias, **args)
-        tokenizer.push_to_hub(opt.model_alias, **args)
-        if os.path.exists(summary_file):
-            shutil.copy2(summary_file, opt.model_alias)
-        extra_desc = f"This model is fine-tuned on `{opt.split_train}` split and validated on `{opt.split_test}` split of tweet_topic."
-        readme = get_readme(
-            model_name=f"{opt.hf_organization}/{opt.model_alias}",
-            metric=summary_file,
-            language_model=opt.model,
-            extra_desc= extra_desc
-            )
-        with open(f"{opt.model_alias}/README.md", "w") as f:
-            f.write(readme)
-        os.system(
-            f"cd {opt.model_alias} && git lfs install && git add . && git commit -m 'model update' && git push && cd ../")
-        shutil.rmtree(f"{opt.model_alias}")  # clean up the cloned repo
-if __name__ == '__main__':
-    main()

readme.py DELETED Viewed

@@ -1,89 +0,0 @@
-import os
-import json
-from typing import Dict
-sample = "#NewVideo Cray Dollas- Water- Ft. Charlie Rose- (Official Music Video)- {{URL}} via {@YouTube@} #watchandlearn {{USERNAME}}"
-bib = """
-@inproceedings{dimosthenis-etal-2022-twitter,
-    title = "{T}witter {T}opic {C}lassification",
-    author = "Antypas, Dimosthenis  and
-    Ushio, Asahi  and
-    Camacho-Collados, Jose  and
-    Neves, Leonardo  and
-    Silva, Vitor  and
-    Barbieri, Francesco",
-    booktitle = "Proceedings of the 29th International Conference on Computational Linguistics",
-    month = oct,
-    year = "2022",
-    address = "Gyeongju, Republic of Korea",
-    publisher = "International Committee on Computational Linguistics"
-}
-"""
-def get_readme(model_name: str,
-               metric: str,
-               language_model,
-               extra_desc: str = ''):
-    with open(metric) as f:
-      metric = json.load(f)
-    return f"""---
-datasets:
-- cardiffnlp/tweet_topic_single
-metrics:
-- f1
-- accuracy
-model-index:
-- name: {model_name}
-  results:
-  - task:
-      type: text-classification
-      name: Text Classification
-    dataset:
-      name: cardiffnlp/tweet_topic_single
-      type: cardiffnlp/tweet_topic_single
-      args: cardiffnlp/tweet_topic_single
-      split: test_2021
-    metrics:
-    - name: F1
-      type: f1
-      value: {metric['test/eval_f1']}
-    - name: F1 (macro)
-      type: f1_macro
-      value: {metric['test/eval_f1_macro']}
-    - name: Accuracy
-      type: accuracy
-      value: {metric['test/eval_accuracy']}
-pipeline_tag: text-classification
-widget:
-- text: "I'm sure the {"{@Tampa Bay Lightning@}"} would’ve rather faced the Flyers but man does their experience versus the Blue Jackets this year and last help them a lot versus this Islanders team. Another meat grinder upcoming for the good guys"
-  example_title: "Example 1"
-- text: "Love to take night time bike rides at the jersey shore. Seaside Heights boardwalk. Beautiful weather. Wishing everyone a safe Labor Day weekend in the US."
-  example_title: "Example 2"
----
-# {model_name}
-This model is a fine-tuned version of [{language_model}](https://huggingface.co/{language_model}) on the [tweet_topic_single](https://huggingface.co/datasets/cardiffnlp/tweet_topic_single). {extra_desc}
-Fine-tuning script can be found [here](https://huggingface.co/datasets/cardiffnlp/tweet_topic_single/blob/main/lm_finetuning.py). It achieves the following results on the test_2021 set:
-- F1 (micro): {metric['test/eval_f1']}
-- F1 (macro): {metric['test/eval_f1_macro']}
-- Accuracy: {metric['test/eval_accuracy']}
-### Usage
-```python
-from transformers import pipeline
-pipe = pipeline("text-classification", "{model_name}")
-topic = pipe("Love to take night time bike rides at the jersey shore. Seaside Heights boardwalk. Beautiful weather. Wishing everyone a safe Labor Day weekend in the US.")
-print(topic)
-```
-### Reference
-```
-{bib}
-```
-"""

tweet_topic_single.py CHANGED Viewed

@@ -4,45 +4,35 @@ from itertools import chain
 import datasets
 logger = datasets.logging.get_logger(__name__)
-_DESCRIPTION = """[TweetTopic](https://arxiv.org/abs/2209.09824)"""
-_VERSION = "1.0.4"
 _CITATION = """
-@inproceedings{dimosthenis-etal-2022-twitter,
-    title = "{T}witter {T}opic {C}lassification",
-    author = "Antypas, Dimosthenis  and
-    Ushio, Asahi  and
-    Camacho-Collados, Jose  and
-    Neves, Leonardo  and
-    Silva, Vitor  and
-    Barbieri, Francesco",
-    booktitle = "Proceedings of the 29th International Conference on Computational Linguistics",
-    month = oct,
-    year = "2022",
-    address = "Gyeongju, Republic of Korea",
-    publisher = "International Committee on Computational Linguistics"
-}
 """
 _HOME_PAGE = "https://cardiffnlp.github.io"
 _LABEL_TYPE = "single"
 _NAME = f"tweet_topic_{_LABEL_TYPE}"
 _URL = f'https://huggingface.co/datasets/cardiffnlp/{_NAME}/raw/main/dataset'
 _URLS = {
-    f"{str(datasets.Split.TEST)}_2020": [f'{_URL}/split_temporal/test_2020.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.TEST)}_2021": [f'{_URL}/split_temporal/test_2021.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.TRAIN)}_2020": [f'{_URL}/split_temporal/train_2020.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.TRAIN)}_2021": [f'{_URL}/split_temporal/train_2021.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.TRAIN)}_all": [f'{_URL}/split_temporal/train_2020.{_LABEL_TYPE}.json', f'{_URL}/split_temporal/train_2021.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.VALIDATION)}_2020": [f'{_URL}/split_temporal/validation_2020.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.VALIDATION)}_2021": [f'{_URL}/split_temporal/validation_2021.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.TRAIN)}_random": [f'{_URL}/split_random/train_random.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.VALIDATION)}_random": [f'{_URL}/split_random/validation_random.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.TEST)}_coling2022_random": [f'{_URL}/split_coling2022_random/test_random.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.TRAIN)}_coling2022_random": [f'{_URL}/split_coling2022_random/train_random.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.TEST)}_coling2022": [f'{_URL}/split_coling2022_temporal/test_2021.{_LABEL_TYPE}.json'],
-    f"{str(datasets.Split.TRAIN)}_coling2022": [f'{_URL}/split_coling2022_temporal/train_2020.{_LABEL_TYPE}.json'],
 }
 class TweetTopicSingleConfig(datasets.BuilderConfig):
     """BuilderConfig"""
@@ -78,14 +68,13 @@ class TweetTopicSingle(datasets.GeneratorBasedBuilder):
                     _key += 1
     def _info(self):
-        names = ["arts_&_culture", "business_&_entrepreneurs", "pop_culture", "daily_life", "sports_&_gaming", "science_&_technology"]
         return datasets.DatasetInfo(
             description=_DESCRIPTION,
             features=datasets.Features(
                 {
                     "text": datasets.Value("string"),
                     "date": datasets.Value("string"),
-                    "label": datasets.features.ClassLabel(names=names),
                     "label_name": datasets.Value("string"),
                     "id": datasets.Value("string")
                 }

 import datasets
 logger = datasets.logging.get_logger(__name__)
+_DESCRIPTION = """[TweetTopic](TBA)"""
+_VERSION = "1.0.1"
 _CITATION = """
+TBA
 """
 _HOME_PAGE = "https://cardiffnlp.github.io"
 _LABEL_TYPE = "single"
 _NAME = f"tweet_topic_{_LABEL_TYPE}"
 _URL = f'https://huggingface.co/datasets/cardiffnlp/{_NAME}/raw/main/dataset'
 _URLS = {
+    str(datasets.Split.TEST): [f'{_URL}/split_temporal/test_2021.{_LABEL_TYPE}.json'],
+    str(datasets.Split.TRAIN): [f'{_URL}/split_temporal/train_2021.{_LABEL_TYPE}.json'],
+    str(datasets.Split.VALIDATION): [f'{_URL}/split_temporal/validation_2021.{_LABEL_TYPE}.json'],
+    f"temporal_2020_{str(datasets.Split.TEST)}": [f'{_URL}/split_temporal/test_2020.{_LABEL_TYPE}.json'],
+    f"temporal_2021_{str(datasets.Split.TEST)}": [f'{_URL}/split_temporal/test_2021.{_LABEL_TYPE}.json'],
+    f"temporal_2020_{str(datasets.Split.TRAIN)}": [f'{_URL}/split_temporal/train_2020.{_LABEL_TYPE}.json'],
+    f"temporal_2021_{str(datasets.Split.TRAIN)}": [f'{_URL}/split_temporal/train_2021.{_LABEL_TYPE}.json'],
+    f"temporal_2020_{str(datasets.Split.VALIDATION)}": [f'{_URL}/split_temporal/validation_2020.{_LABEL_TYPE}.json'],
+    f"temporal_2021_{str(datasets.Split.VALIDATION)}": [f'{_URL}/split_temporal/validation_2021.{_LABEL_TYPE}.json'],
+    f"random_{str(datasets.Split.TRAIN)}": [f'{_URL}/split_random/train_random.{_LABEL_TYPE}.json'],
+    f"random_{str(datasets.Split.VALIDATION)}": [f'{_URL}/split_random/validation_random.{_LABEL_TYPE}.json'],
+    f"coling2022_random_{str(datasets.Split.TEST)}": [f'{_URL}/split_coling2022_random/test_random.{_LABEL_TYPE}.json'],
+    f"coling2022_random_{str(datasets.Split.TRAIN)}": [f'{_URL}/split_coling2022_random/train_random.{_LABEL_TYPE}.json'],
+    f"coling2022_temporal_{str(datasets.Split.TEST)}": [f'{_URL}/split_coling2022_temporal/test_2021.{_LABEL_TYPE}.json'],
+    f"coling2022_temporal_{str(datasets.Split.TRAIN)}": [f'{_URL}/split_coling2022_temporal/train_2020.{_LABEL_TYPE}.json'],
 }
 class TweetTopicSingleConfig(datasets.BuilderConfig):
     """BuilderConfig"""
                     _key += 1
     def _info(self):
         return datasets.DatasetInfo(
             description=_DESCRIPTION,
             features=datasets.Features(
                 {
                     "text": datasets.Value("string"),
                     "date": datasets.Value("string"),
+                    "label": datasets.Value("int32"),
                     "label_name": datasets.Value("string"),
                     "id": datasets.Value("string")
                 }