Update parquet files

.gitattributes

@@ -1,27 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bin.* filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zstandard filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

default/stanzas-test.parquet

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

default/stanzas-train.parquet

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

default/stanzas-validation.parquet

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

stanzas.py

@@ -1,106 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
-#
-# 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.
-"""Stanzas"""
-import csv
-
-import datasets
-
-
-_CITATION = """
-@InProceedings{--,
-  author = {---},
-  title = {---},
-  booktitle = {---},
-  year = 2021,
-  address = "---"
-}
-"""
-
-_DESCRIPTION = """\
-Stanzas
-"""
-
-
-_HOMEPAGE = "https://github.com/versae/bibles/"
-
-STANZAS_BASE_URI = "https://huggingface.co/datasets/linhd-postdata/stanzas/resolve/main"
-STANZAS = {
-    "validation": f"{STANZAS_BASE_URI}/eval.csv",
-    "test": f"{STANZAS_BASE_URI}/test.csv",
-    "train": f"{STANZAS_BASE_URI}/train.csv"
-}
-
-
-class StanzasConfig(datasets.BuilderConfig):
-    """BuilderConfig for NorNE."""
-
-    def __init__(self, **kwargs):
-        """BuilderConfig for Stanzas.
-        Args:
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(StanzasConfig, self).__init__(**kwargs)
-
-
-class Stanzas(datasets.GeneratorBasedBuilder):
-    """Stanzas"""
-
-    StanzasConfig(
-        name="default",version=datasets.Version("1.0.0"), description="Stanzas")
-
-    def _info(self):
-        labels = ['ovillejo', 'romance', 'octava_real', 'couplet', 'octava',
-       'cuarteta', 'copla_real', 'serventesio', 'haiku', 'cuaderna_vía',
-       'tercetillo', 'cantar', 'sextilla', 'espinela', 'lira',
-       'octavilla', 'chamberga', 'endecha_real', 'romance_arte_mayor',
-       'redondilla', 'septilla', 'silva_arromanzada', 'seguidilla',
-       'cuarteto_lira', 'cuarteto', 'décima_antigua', 'seguidilla_gitana',
-       'seguidilla_compuesta', 'copla_castellana', 'quintilla', 'soleá',
-       'estrofa_manriqueña', 'quinteto', 'terceto', 'sexta_rima',
-       'unknown', 'estrofa_sáfica', 'estrofa_francisco_de_la_torre',
-       'novena', 'sexteto', 'copla_arte_menor', 'copla_arte_mayor',
-       'terceto_monorrimo', 'copla_mixta', 'septeto', 'sexteto_lira']
-        self.labels = labels
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=datasets.Features(
-                {
-                    "text": datasets.Value("string"),
-                    "label": datasets.ClassLabel(names=labels),
-                }
-            ),
-            supervised_keys=None,
-            homepage=_HOMEPAGE,
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        URLS = {key: STANZAS[key] for key in STANZAS.keys()}
-        downloaded_files = dl_manager.download(URLS)
-        return [
-            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepath": downloaded_files["train"]}),
-            datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={"filepath": downloaded_files["validation"]}),
-            datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"filepath": downloaded_files["test"]}),
-        ]
-
-    def _generate_examples(self, filepath):
-        with open(filepath, encoding="utf-8") as csv_file:
-            csv_reader = csv.reader(csv_file, delimiter=",")
-            next(csv_reader)  # skip header
-            for idx, (text, label) in enumerate(csv_reader):
-                yield int(idx), {
-                    "text": text,
-                    "label": label,
-                }

stanzas_eval.py

@@ -1,706 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Evaluating models for BibleBERT
-Copyright 2021 © Javier de la Rosa
-"""
-
-# Dependencies
-# !pip install -qU transformers sacrebleu scikit-learn datasets seqeval conllu pyarrow nltk
-
-# Dependencies and helper functions
-import argparse
-import logging
-import os
-import random
-import sys
-from dataclasses import dataclass
-from dataclasses import field
-from pathlib import Path
-from typing import Optional
-
-import datasets
-import numpy as np
-import pandas as pd
-# from datasets import ClassLabel
-from datasets import load_dataset
-from nltk.tokenize import word_tokenize
-from nltk.tokenize.treebank import TreebankWordDetokenizer
-from seqeval.metrics.sequence_labeling import accuracy_score as seq_accuracy_score
-from seqeval.metrics.sequence_labeling import f1_score as seq_f1_score
-from seqeval.metrics.sequence_labeling import precision_score as seq_precision_score
-from seqeval.metrics.sequence_labeling import recall_score as seq_recall_score
-from seqeval.metrics.sequence_labeling import classification_report as seq_classification_report
-from sklearn.metrics import accuracy_score as sk_accuracy_score
-from sklearn.metrics import f1_score as sk_f1_score
-from sklearn.metrics import precision_score as sk_precision_score
-from sklearn.metrics import recall_score as sk_recall_score
-from sklearn.metrics import classification_report as sk_classification_report
-# from sklearn.preprocessing import MultiLabelBinarizer
-from tqdm import tqdm
-from transformers import (
-    AutoConfig,
-    AutoModelForTokenClassification,
-    AutoModelForSequenceClassification,
-    AutoTokenizer,
-    RobertaTokenizer,
-    RobertaTokenizerFast,
-    DataCollatorForTokenClassification,
-    DataCollatorWithPadding,
-    PreTrainedTokenizerFast,
-    Trainer,
-    TrainingArguments,
-    pipeline,
-    set_seed,
-)
-# from transformers.training_args import TrainingArguments
-import wandb
-
-BIBLES_BASE_URI = "https://huggingface.co/datasets/linhd-postdata/stanzas/resolve/main"
-BIBLES = {
-    "validation": f"{BIBLES_BASE_URI}/eval.csv",
-    "test": f"{BIBLES_BASE_URI}/test.csv",
-    "train": f"{BIBLES_BASE_URI}/train.csv"
-}
-
-
-# Helper Funtions
-def printm(string):
-    print(str(string))
-
-
-# Tokenize all texts and align the labels with them.
-def tokenize_and_align_labels(
-    tokenizer, examples, text_column_name, max_length, padding,
-    label_column_name, label_to_id, label_all_tokens
-):
-    tokenized_inputs = tokenizer(
-        examples[text_column_name],
-        max_length=max_length,
-        padding=padding,
-        truncation=True,
-        # We use this argument because the texts in our dataset are lists of words (with a label for each word).
-        is_split_into_words=True,
-    )
-    labels = []
-    for i, label in enumerate(examples[label_column_name]):
-        word_ids = tokenized_inputs.word_ids(batch_index=i)
-        previous_word_idx = None
-        label_ids = []
-        for word_idx in word_ids:
-            # Special tokens have a word id that is None. We set the label to -100 so they are automatically
-            # ignored in the loss function.
-            if word_idx is None:
-                label_ids.append(-100)
-            # We set the label for the first token of each word.
-            elif word_idx != previous_word_idx:
-                label_ids.append(label_to_id[label[word_idx]])
-            # For the other tokens in a word, we set the label to either the current label or -100, depending on
-            # the label_all_tokens flag.
-            else:
-                label_ids.append(label_to_id[label[word_idx]] if label_all_tokens else -100)
-            previous_word_idx = word_idx
-
-        labels.append(label_ids)
-    tokenized_inputs["labels"] = labels
-    return tokenized_inputs
-
-
-# Metrics
-def token_compute_metrics(pairs, label_list):
-    """Token metrics based on seqeval"""
-    raw_predictions, labels = pairs
-    predictions = np.argmax(raw_predictions, axis=2)
-
-    # Remove ignored index (special tokens)
-    true_predictions = [
-        [label_list[p] for (p, l) in zip(prediction, label) if l != -100]
-        for prediction, label in zip(predictions, labels)
-    ]
-    true_probas = [
-        [label_list[p] for (p, l) in zip(prediction, label) if l != -100]
-        for prediction, label in zip(predictions, labels)
-    ]
-    true_labels = [
-        [label_list[l] for (p, l) in zip(prediction, label) if l != -100]
-        for prediction, label in zip(predictions, labels)
-    ]
-    raw_scores = (
-        np.exp(raw_predictions) / np.exp(raw_predictions).sum(-1, keepdims=True)
-    )
-    scores = raw_scores.max(axis=2)
-    true_scores = [
-        [(s, l) for (s, l) in zip(score, label) if l != -100]
-        for score, label in zip(scores, labels)
-    ]
-
-    # mlb = MultiLabelBinarizer()  # sparse_output=True
-    # true_predictions = mlb.fit_transform(true_predictions)
-    # mlb = MultiLabelBinarizer()  # sparse_output=True
-    # true_labels = mlb.fit_transform(true_labels)
-    # wandb.log({
-    #     "roc" : wandb.plot.roc_curve(
-    #         labels,
-    #         predictions,
-    #         labels=label_list
-    # )})
-    metrics = {
-        "accuracy": seq_accuracy_score(true_labels, true_predictions),
-        "precision_micro": seq_precision_score(true_labels, true_predictions, average="micro"),
-        "recall_micro": seq_recall_score(true_labels, true_predictions, average="micro"),
-        "f1_micro": seq_f1_score(true_labels, true_predictions, average="micro"),
-        "precision_macro": seq_precision_score(true_labels, true_predictions, average="macro"),
-        "recall_macro": seq_recall_score(true_labels, true_predictions, average="macro"),
-        "f1_macro": seq_f1_score(true_labels, true_predictions, average="macro"),
-        # "report": seq_classification_report(true_labels, true_predictions, digits=4)
-    }
-    reports = seq_classification_report(
-        true_labels, true_predictions, output_dict=True, zero_division=0,
-    )
-    for label, report in reports.items():
-        for metric_key, metric_value in report.items():
-            metric_title = metric_key.replace(" avg", "_avg", 1)
-            metrics.update({
-                f"label_{label}_{metric_title}": metric_value,
-            })
-    # labels_to_plot = label_list.copy()
-    # if "O" in labels_to_plot:
-    #     labels_to_plot.remove("O")
-    flat_true_labels = sum(true_labels, [])
-    flat_true_predictions = sum(true_predictions, [])
-    wandb.log({
-        # "roc": wandb.plot.roc_curve(
-        #     labels.reshape(-1),
-        #     raw_scores.reshape(-1, raw_predictions.shape[-1]),
-        #     labels=label_list,
-        #     classes_to_plot=labels_to_plot,
-        # ),
-        "matrix": wandb.sklearn.plot_confusion_matrix(
-            flat_true_labels, flat_true_predictions, label_list
-        )
-    })
-    return metrics
-
-
-def sequence_compute_metrics(pairs, label_list):
-    """Sequence metrics based on sklearn"""
-    raw_predictions, labels = pairs
-    predictions = np.argmax(raw_predictions, axis=1)
-    metrics = {
-        "accuracy": sk_accuracy_score(labels, predictions),
-        "precision_micro": sk_precision_score(labels, predictions, average="micro"),
-        "recall_micro": sk_recall_score(labels, predictions, average="micro"),
-        "f1_micro": sk_f1_score(labels, predictions, average="micro"),
-        "precision_macro": sk_precision_score(labels, predictions, average="macro"),
-        "recall_macro": sk_recall_score(labels, predictions, average="macro"),
-        "f1_macro": sk_f1_score(labels, predictions, average="macro"),
-        # "report": sk_classification_report(labels, predictions, digits=4)
-    }
-    reports = sk_classification_report(
-        labels, predictions, target_names=label_list, output_dict=True,
-    )
-    for label, report in reports.items():
-        if not isinstance(report, dict):
-            report = {"": report}
-        for metric_key, metric_value in report.items():
-            metric_title = metric_key.replace(" avg", "_avg", 1)
-            metrics.update({
-                f"label_{label}_{metric_title}": metric_value,
-            })
-    wandb.log({
-        "roc": wandb.plot.roc_curve(
-            labels, raw_predictions, labels=label_list
-        ),
-        "matrix": wandb.sklearn.plot_confusion_matrix(
-            labels, predictions, label_list
-        )
-    })
-    return metrics
-
-
-def write_file(kind, metrics, output_dir, save_artifact=False):
-    output_file = output_dir / f"{kind}_results.txt"
-    headers = []
-    label_headers = []
-    data = []
-    label_data = []
-    with open(output_file, "w") as writer:
-        printm(f"**{kind.capitalize()} results**")
-        for key, value in metrics.items():
-            printm(f"\t{key} = {value}")
-            writer.write(f"{key} = {value}\n")
-            title = key.replace("eval_", "", 1)
-            if title.startswith("label_"):
-                label_headers.append(title.replace("label_", "", 1))
-                label_data.append(value)
-            else:
-                headers.append(title)
-                data.append(value)
-            wandb.log({f"{kind}:{title}": value})
-    wandb.log({kind: wandb.Table(data=[data], columns=headers)})
-    if label_headers:
-        wandb.log({
-            f"{kind}:labels": wandb.Table(
-                data=[label_data], columns=label_headers
-            )
-        })
-    if save_artifact:
-        artifact = wandb.Artifact(kind, type="result")
-        artifact.add_file(str(output_file))
-        wandb.log_artifact(artifact)
-
-
-def dataset_select(dataset, size):
-    dataset_len = len(dataset)
-    if size < 0 or size > dataset_len:
-        return dataset
-    elif size <= 1:  # it's a percentage
-        return dataset.select(range(int(size * dataset_len)))
-    else:  # it's a number
-        return dataset.select(range(int(size)))
-
-
-def main(args):
-    # Set seed
-    if args.run:
-        seed = random.randrange(10**3)
-    else:
-        seed = args.seed
-    set_seed(seed)
-    # Run name
-    model_name = args.model_name
-    model_name = model_name[2:] if model_name.startswith("./") else model_name
-    model_name = model_name[1:] if model_name.startswith("/") else model_name
-    run_name = f"{model_name}_{args.task_name}"
-    run_name = f"{run_name}_{args.dataset_config or args.dataset_name}"
-    run_name = run_name.replace("/", "-")
-    run_name = f"{run_name}_l{str(args.dataset_language)}"
-    run_name = f"{run_name}_c{str(args.dataset_century)}"
-    run_name = f"{run_name}_e{str(args.num_train_epochs)}"
-    run_name = f"{run_name}_lr{str(args.learning_rate)}"
-    run_name = f"{run_name}_ws{str(args.warmup_steps)}"
-    run_name = f"{run_name}_wd{str(args.weight_decay)}"
-    run_name = f"{run_name}_s{str(seed)}"
-    run_name = f"{run_name}_eas{str(args.eval_accumulation_steps)}"
-    if args.max_length != 512:
-        run_name = f"{run_name}_seq{str(args.max_length)}"
-    if args.label_all_tokens:
-        run_name = f"{run_name}_labelall"
-    if args.run:
-        run_name = f"{run_name}_r{str(args.run)}"
-    output_dir = Path(args.output_dir) / run_name
-    # Tokenizer settings
-    padding = "longest"  # args.task_name not in ("ner", "pos")  # default: False @param ["False", "'max_length'"] {type: 'raw'}
-    max_length = args.max_length #@param {type: "number"}
-    # Training settings
-    weight_decay = args.weight_decay  #@param {type: "number"}
-    adam_beta1 = 0.9  #@param {type: "number"}
-    adam_beta2 = 0.999  #@param {type: "number"}
-    adam_epsilon = 1e-08  #@param {type: "number"}
-    max_grad_norm = 1.0  #@param {type: "number"}
-    save_total_limit = 1  #@param {type: "integer"}
-    load_best_model_at_end = False  #@param {type: "boolean"}
-    # wandb
-    wandb.init(name=run_name, project="postdata")
-    wandb.log({
-        "seed": int(seed),
-    })
-    # Loading Dataset
-    print("\n\n#####################################")
-    print(args.model_name)
-    print(args.task_name)
-    print(args.dataset_config)
-    print(args.dataset_language)
-    print(args.dataset_century)
-    train_split = args.dataset_split_train
-    test_split = args.dataset_split_test
-    validation_split = args.dataset_split_validation
-    if ":" in args.dataset_name:
-        dataset_name, dataset_config = args.dataset_name.split(":")
-    else:
-        dataset_name = args.dataset_name
-        dataset_config = args.dataset_config
-    use_auth_token = os.environ.get("AUTH_TOKEN", None)
-    if dataset_config is None or len(dataset_config) == 0:
-        dataset = load_dataset(dataset_name, use_auth_token=use_auth_token)
-    elif dataset_name == "csv" and dataset_config:
-        dataset = load_dataset(
-            dataset_name,
-            data_files={
-                "train": BIBLES["train"](dataset_config),
-                "validation": BIBLES["validation"](dataset_config),
-                "test": BIBLES["test"](dataset_config),
-            },
-            use_auth_token=use_auth_token)
-    else:
-        dataset = load_dataset(dataset_name, dataset_config, use_auth_token=use_auth_token)
-    if args.dataset_language and args.dataset_language.lower() not in ("all", "balanced"):
-        dataset = dataset.filter(lambda x: x["language"] == args.dataset_language)
-    if args.dataset_century and args.dataset_century.lower() != "all":
-        dataset = dataset.filter(lambda x: x["century"] in args.dataset_century)
-    if dataset["train"].shape[0] == 0 or dataset["test"].shape[0] == 0 or dataset["validation"].shape[0] == 0:
-        print(f"Not enough data for {str(args.dataset_language)} on {str(args.dataset_century)}: {str(dataset.shape)}")
-        return
-    column_names = dataset[train_split].column_names
-    features = dataset[train_split].features
-    if "tokens" in column_names:
-        text_column_name = "tokens"
-    elif "text" in column_names:
-        text_column_name = "text"
-    else:
-        text_column_name = column_names[0]
-    if f"{args.task_name}_tags" in column_names:
-        label_column_name = f"{args.task_name}_tags"
-    elif "label" in column_names:
-        label_column_name = "label"
-    else:
-        label_column_name = column_names[1]
-    if dataset_name == "csv":
-        label_list = list(set(dataset[train_split][label_column_name]))
-    elif isinstance(features[label_column_name], datasets.features.Sequence):
-        label_list = features[label_column_name].feature.names
-    else:
-        label_list = features[label_column_name].names
-    label_to_id = {i: i for i in range(len(label_list))}
-    num_labels = len(label_list)
-    print(f"Number of labels: {num_labels}")
-    print({label.split("-")[-1] for label in label_list})
-
-    # Training
-    config = AutoConfig.from_pretrained(
-        args.model_name,
-        num_labels=num_labels,
-        finetuning_task=args.task_name,
-        cache_dir=args.cache_dir,
-        force_download=args.force_download,
-    )
-    tokenizer = AutoTokenizer.from_pretrained(
-        args.model_name,
-        cache_dir=args.cache_dir,
-        use_fast=True,
-        force_download=args.force_download,
-    )
-    if isinstance(tokenizer, (RobertaTokenizer, RobertaTokenizerFast)):
-        tokenizer = AutoTokenizer.from_pretrained(
-            args.model_name,
-            cache_dir=args.cache_dir,
-            use_fast=True,
-            force_download=args.force_download,
-            add_prefix_space=True,
-        )
-
-    tokenizer_test_sentence = """
-    Ya que el Ángel del Señor tiene nombre propio, y su nombre es Yahveh.
-    """.strip()
-    printm("""Tokenizer test""")
-    printm(f"> {tokenizer_test_sentence}")
-    printm(tokenizer.tokenize(tokenizer_test_sentence))
-    printm(tokenizer(tokenizer_test_sentence).input_ids)
-    # STILTs
-    is_stilt = args.model_name in args.stilt.split(",") or args.stilt == "all"
-    model_config = dict(
-        from_tf=bool(".ckpt" in args.model_name),
-        config=config,
-        cache_dir=args.cache_dir,
-        force_download=args.force_download,
-    )
-    # Token tasks
-    if args.task_name in ("pos", "ner"):
-        if is_stilt:
-            # model = AutoModelForTokenClassification.from_config(
-            #     config=config
-            # )
-            model_config.pop("config")
-            model = AutoModelForTokenClassification.from_pretrained(
-                args.model_name, num_labels=num_labels, ignore_mismatched_sizes=True, **model_config,
-            )
-        else:
-            model = AutoModelForTokenClassification.from_pretrained(
-                args.model_name, **model_config,
-            )
-        # Preprocessing the dataset
-        tokenized_datasets = dataset.map(
-            lambda examples: tokenize_and_align_labels(
-                tokenizer, examples, text_column_name, max_length, padding,
-                label_column_name, label_to_id, args.label_all_tokens),
-            batched=True,
-            load_from_cache_file=not args.overwrite_cache,
-            num_proc=os.cpu_count(),
-        )
-        # Data collator
-        data_collator = DataCollatorForTokenClassification(tokenizer)
-        compute_metrics = token_compute_metrics
-    # Sequence tasks
-    else:
-        if is_stilt:
-            # model = AutoModelForSequenceClassification.from_config(
-            #     config=config
-            # )
-            model_config.pop("config")
-            model = AutoModelForSequenceClassification.from_pretrained(
-                args.model_name, num_labels=num_labels, ignore_mismatched_sizes=True, **model_config,
-            )
-        else:
-            model = AutoModelForSequenceClassification.from_pretrained(
-                args.model_name, **model_config,
-            )
-        # Preprocessing the dataset
-        tokenized_datasets = dataset.map(
-            lambda examples: tokenizer(
-                examples[text_column_name],
-                max_length=max_length,
-                padding=padding,
-                truncation=True,
-                is_split_into_words=False,
-            ),
-            batched=True,
-            load_from_cache_file=not args.overwrite_cache,
-            num_proc=os.cpu_count(),
-        )
-        # Data collator
-        data_collator = DataCollatorWithPadding(
-            tokenizer,
-            max_length=max_length,
-            padding=padding,
-        )
-        compute_metrics = sequence_compute_metrics
-    train_dataset = dataset_select(
-        tokenized_datasets[train_split], args.max_train_size
-    )
-    test_dataset = dataset_select(
-        tokenized_datasets[test_split], args.max_test_size
-    )
-    validation_dataset = dataset_select(
-        tokenized_datasets[validation_split], args.max_validation_size
-    )
-    wandb.log({
-        "train_size": len(train_dataset),
-        "test_size": len(test_dataset),
-        "validation_size": len(validation_dataset),
-    })
-    samples_per_batch = (
-        train_dataset.shape[0] / args.train_batch_size
-    )
-    total_steps = args.num_train_epochs * samples_per_batch
-    warmup_steps = int(args.warmup_steps * total_steps)
-    wandb.log({
-        "total_steps": int(total_steps),
-        "total_warmup_steps": warmup_steps
-    })
-    do_eval = args.do_eval and (validation_split in tokenized_datasets)
-    do_test = args.do_test and (test_split in tokenized_datasets)
-    do_predict = args.do_predict and (test_split in tokenized_datasets)
-    training_args = TrainingArguments(
-        output_dir=output_dir.as_posix(),
-        overwrite_output_dir=args.overwrite_output_dir,
-        do_train=args.do_train,
-        do_eval=do_eval,
-        do_predict=do_test or do_predict,
-        per_device_train_batch_size=int(args.train_batch_size),
-        per_device_eval_batch_size=int(args.eval_batch_size or args.train_batch_size),
-        learning_rate=float(args.learning_rate),
-        weight_decay=weight_decay,
-        adam_beta1=adam_beta1,
-        adam_beta2=adam_beta2,
-        adam_epsilon=adam_epsilon,
-        max_grad_norm=max_grad_norm,
-        num_train_epochs=args.num_train_epochs,
-        warmup_steps=warmup_steps,
-        load_best_model_at_end=load_best_model_at_end,
-        seed=seed,
-        save_total_limit=save_total_limit,
-        run_name=run_name,
-        disable_tqdm=False,
-        eval_steps=1000,
-        eval_accumulation_steps=args.eval_accumulation_steps or None,  # it was not set
-        dataloader_num_workers=64,  # it was not set
-    )
-    # Initialize our Trainer
-    trainer = Trainer(
-        model=model,
-        args=training_args,
-        train_dataset=train_dataset,
-        eval_dataset=validation_dataset if do_eval else None,
-        tokenizer=tokenizer,
-        data_collator=data_collator,
-        compute_metrics=lambda pairs: compute_metrics(pairs, label_list),
-    )
-    if args.do_train:
-        train_result = trainer.train()
-        trainer.save_model()  # Saves the tokenizer too for easy upload
-        write_file("train", train_result.metrics, output_dir, save_artifact=args.save_artifacts)
-        # Need to save the state, since Trainer.save_model saves only the tokenizer with the model
-        trainer.state.save_to_json(output_dir / "trainer_state.json")
-    # Evaluation
-    if do_eval:
-        printm(f"**Evaluate**")
-        results = trainer.evaluate()
-        write_file("eval", results, output_dir, save_artifact=args.save_artifacts)
-    # Tesing and predicting
-    if do_test or do_predict:
-        printm("**Test**")
-        predictions, labels, metrics = trainer.predict(test_dataset)
-        if not do_predict:
-            write_file("test", metrics, output_dir, save_artifact=args.save_artifacts)
-        if args.task_name in ("ner", "pos"):
-            predictions = np.argmax(predictions, axis=2)
-            # Remove ignored index (special tokens)
-            true_predictions = [
-                [label_list[p] for (p, l) in zip(prediction, label) if l != -100]
-                for prediction, label in zip(predictions, labels)
-            ]
-        else:
-            predictions = np.argmax(predictions, axis=1)
-            true_predictions = [
-                label_list[p] for (p, l) in zip(predictions, labels) if l != -100
-            ]
-        # Save predictions
-        output_test_predictions_file = os.path.join(output_dir, "test_predictions.txt")
-        output_test_predictions = "\n".join(" ".join(map(str, p)) for p in true_predictions)
-        with open(output_test_predictions_file, "a+") as writer:
-            writer.write(output_test_predictions)
-        if args.save_artifacts:
-            artifact = wandb.Artifact("predictions", type="result")
-            artifact.add_file(output_test_predictions_file)
-            wandb.log_artifact(artifact)
-    # # Log the results
-    # logfile = output_dir / "evaluation.csv"
-    # # Check if logfile exist
-    # try:
-    #     f = open(logfile)
-    #     f.close()
-    # except FileNotFoundError:
-    #     with open(logfile, 'a+') as f:
-    #         f.write("model_name" + "\t" + "data_language" + "\t" + "task_name" + "\t" "learning_rate"+ "\t" + "num_epochs"+ "\t" + "warmup_steps"+ "\t" + "validation_f1" +"\t"+"test_f1"+"\n")
-    # with open(logfile, 'a') as f:
-    #     print(results)
-    #     f.write(args.model_name + "\t" + (args.dataset_config or args.dataset_name) + "\t" + args.task_name + "\t" + str(args.learning_rate) + "\t" + str(args.num_train_epochs)+ "\t" + str(warmup_steps)+ "\t" + str(results['eval_f1']) + "\t" + str(metrics['eval_f1']) + "\n")
-
-
-if __name__ == "__main__":
-    # yesno = lambda x: str(x).lower() in {'true', 't', '1', 'yes', 'y'}
-    parser = argparse.ArgumentParser(description=f""
-    f"Evaluating BERT models for sequence classification on Bibles"""
-    f"", epilog=f"""Example usage:
-    {__file__} --task_name sequence --model_name "bert-base-multilingual-cased"
-    """, formatter_class=argparse.RawTextHelpFormatter)
-    parser.add_argument('--model_name',
-        metavar='model_name', help='Model name or path')
-    parser.add_argument('--dataset_name', default="csv",
-        metavar='dataset_name', help='Dataset name. It might enforce a config if added after a semicolon: "conll2002:es". This will ignore dataset_config, useful when run in grid search')
-    parser.add_argument('--dataset_config',
-        metavar='dataset_config', help='Dataset config name')
-    parser.add_argument('--dataset_language', default="all",
-        metavar='dataset_language', help='Dataset language name')
-    parser.add_argument('--dataset_century', default="all",
-        metavar='dataset_century', help='Dataset century')
-
-    parser.add_argument('--dataset_split_train', default="train",
-        metavar='dataset_split_train', help='Dataset train split name')
-    parser.add_argument('--dataset_split_test', default="test",
-        metavar='dataset_split_test', help='Dataset test split name')
-    parser.add_argument('--dataset_split_validation', default="validation",
-        metavar='dataset_split_validation', help='Dataset validation split name')
-
-    parser.add_argument('--max_train_size', type=float, default=-1.0,
-        metavar='max_train_size', help='Percentage of train dataset or number of rows to use')
-    parser.add_argument('--max_test_size', type=float, default=-1.0,
-        metavar='max_test_size', help='Percentage of test dataset or number of rows to use')
-    parser.add_argument('--max_validation_size', type=float, default=-1.0,
-        metavar='max_validation_size', help='Percentage of validation dataset or number of rows to use')
-
-    parser.add_argument('--do_train',
-        metavar='do_train', default=True, type=bool,
-        help='Run training',
-    )
-    parser.add_argument('--do_eval',
-        metavar='do_eval', default=True, type=bool,
-        help='Run evaluation on validation test',
-    )
-    parser.add_argument('--do_test',
-        metavar='do_test', default=True, type=bool,
-        help='Run evaluation on test set',
-    )
-    parser.add_argument('--do_predict',
-        metavar='do_predict', default=False, type=bool,
-        help='Run prediction only on test set',
-    )
-    parser.add_argument('--task_name',
-        metavar='task_name', default="ner",
-        help='Task name (supported in the dataset), either ner or pos',
-    )
-    parser.add_argument('--num_train_epochs',
-        metavar='num_train_epochs', default=4, type=float,
-        help='Number of training epochs',
-    )
-    parser.add_argument('--eval_accumulation_steps',
-        metavar='eval_accumulation_steps', default=0, type=int,
-        help='Number of predictions steps to accumulate the output tensors for, before moving the results to the CPU.',
-    )
-    parser.add_argument('--cache_dir',
-        metavar='cache_dir', default="/var/ml/cache/",
-        help='Cache dir for the transformer library',
-    )
-    parser.add_argument('--overwrite_cache',
-        metavar='overwrite_cache', default=False, type=bool,
-        help='Overwrite cache dir if present',
-    )
-    parser.add_argument('--output_dir',
-        metavar='output_dir', default="/var/ml/output/",
-        help='Output dir for models and logs',
-    )
-    parser.add_argument('--overwrite_output_dir',
-        metavar='overwrite_output_dir', default=True, type=bool,
-        help='Overwrite output dir if present',
-    )
-    parser.add_argument('--seed',
-        metavar='seed', type=int, default=2021,
-        help='Seed for the experiments',
-    )
-    parser.add_argument('--run',
-        metavar='run', type=int,
-        help='Control variable for doing several runs of the same experiment. It will force random seeds even across the same set of parameters fo a grid search',
-    )
-    parser.add_argument('--train_batch_size',
-        metavar='train_batch_size', type=int, default=8,
-        help='Batch size for training',
-    )
-    parser.add_argument('--eval_batch_size',
-        metavar='eval_batch_size', type=int,
-        help='Batch size for evaluation. Defaults to train_batch_size',
-    )
-    parser.add_argument('--max_length',
-        metavar='max_length', type=int, default=512,
-        help='Maximum sequence length',
-    )
-    parser.add_argument('--learning_rate',
-        metavar='learning_rate', type=str, default="3e-05",
-        help='Learning rate',
-    )
-    parser.add_argument('--warmup_steps',
-        metavar='warmup_steps', type=float, default=0.0,
-        help='Warmup steps as percentage of the total number of steps',
-    )
-    parser.add_argument('--weight_decay',
-        metavar='weight_decay', type=float, default=0.0,
-        help='Weight decay',
-    )
-    parser.add_argument('--label_all_tokens',
-        metavar='label_all_tokens', type=bool, default=False,
-        help=('Whether to put the label for one word on all tokens of '
-              'generated by that word or just on the one (in which case the '
-              'other tokens will have a padding index).'),
-    )
-    parser.add_argument('--force_download',
-        metavar='force_download', type=bool, default=False,
-        help='Force the download of model, tokenizer, and config',
-    )
-    parser.add_argument('--save_artifacts',
-        metavar='save_artifacts', type=bool, default=False,
-        help='Save train, eval, and test files in Weight & Biases',
-    )
-    parser.add_argument('--stilt',
-        metavar='stilt', type=str, default="",
-        help='Specify models already fine-tuned for other tasks',
-    )
-
-    args = parser.parse_args()
-    main(args)

stanzas_eval.yaml

@@ -1,39 +0,0 @@
-name: mBert stanzas evaluation
-project: stanzas-mbert-eval
-program: stanzas_eval.py
-command:
-  - ${env}
-  - ${interpreter}
-  - ${program}
-  - ${args}
-method: grid
-metric:
-  name: eval:f1_macro
-  goal: maximize
-parameters:
-  dataset_name:
-    value: linhd-postdata/stanzas
-  task_name:
-    value: sequence
-  model_name:
-    value: bert-base-multilingual-cased
-  # force_download:
-  #   value: true
-  num_train_epochs:
-    value: 3
-  # warmup_steps:
-  #   value: 0.1
-  weight_decay:
-    value: 0.0
-  learning_rate:
-    value: 3e-5
-  train_batch_size:
-    value: 8
-  cache_dir:
-    value: ./cache
-  output_dir:
-    value: ./output
-  save_artifacts:
-    value: true
-  # run:
-  #   values: [1, 2, 3]