SinaTools 0.1.40__py2.py3-none-any.whl → 1.0.1__py2.py3-none-any.whl

sinatools/arabert/araelectra/build_pretraining_dataset.py

@@ -1,230 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The Google Research Authors.
-#
-# 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.
-
-"""Writes out text data as tfrecords that ELECTRA can be pre-trained on."""
-
-import argparse
-import multiprocessing
-import os
-import random
-import time
-import tensorflow as tf
-
-from model import tokenization
-from util import utils
-
-
-def create_int_feature(values):
-  feature = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))
-  return feature
-
-
-class ExampleBuilder(object):
-  """Given a stream of input text, creates pretraining examples."""
-
-  def __init__(self, tokenizer, max_length):
-    self._tokenizer = tokenizer
-    self._current_sentences = []
-    self._current_length = 0
-    self._max_length = max_length
-    self._target_length = max_length
-
-  def add_line(self, line):
-    """Adds a line of text to the current example being built."""
-    line = line.strip().replace("\n", " ")
-    if (not line) and self._current_length != 0:  # empty lines separate docs
-      return self._create_example()
-    bert_tokens = self._tokenizer.tokenize(line)
-    bert_tokids = self._tokenizer.convert_tokens_to_ids(bert_tokens)
-    self._current_sentences.append(bert_tokids)
-    self._current_length += len(bert_tokids)
-    if self._current_length >= self._target_length:
-      return self._create_example()
-    return None
-
-  def _create_example(self):
-    """Creates a pre-training example from the current list of sentences."""
-    # small chance to only have one segment as in classification tasks
-    if random.random() < 0.1:
-      first_segment_target_length = 100000
-    else:
-      # -3 due to not yet having [CLS]/[SEP] tokens in the input text
-      first_segment_target_length = (self._target_length - 3) // 2
-
-    first_segment = []
-    second_segment = []
-    for sentence in self._current_sentences:
-      # the sentence goes to the first segment if (1) the first segment is
-      # empty, (2) the sentence doesn't put the first segment over length or
-      # (3) 50% of the time when it does put the first segment over length
-      if (len(first_segment) == 0 or
-          len(first_segment) + len(sentence) < first_segment_target_length or
-          (len(second_segment) == 0 and
-           len(first_segment) < first_segment_target_length and
-           random.random() < 0.5)):
-        first_segment += sentence
-      else:
-        second_segment += sentence
-
-    # trim to max_length while accounting for not-yet-added [CLS]/[SEP] tokens
-    first_segment = first_segment[:self._max_length - 2]
-    second_segment = second_segment[:max(0, self._max_length -
-                                         len(first_segment) - 3)]
-
-    # prepare to start building the next example
-    self._current_sentences = []
-    self._current_length = 0
-    # small chance for random-length instead of max_length-length example
-    if random.random() < 0.05:
-      self._target_length = random.randint(5, self._max_length)
-    else:
-      self._target_length = self._max_length
-
-    return self._make_tf_example(first_segment, second_segment)
-
-  def _make_tf_example(self, first_segment, second_segment):
-    """Converts two "segments" of text into a tf.train.Example."""
-    vocab = self._tokenizer.vocab
-    input_ids = [vocab["[CLS]"]] + first_segment + [vocab["[SEP]"]]
-    segment_ids = [0] * len(input_ids)
-    if second_segment:
-      input_ids += second_segment + [vocab["[SEP]"]]
-      segment_ids += [1] * (len(second_segment) + 1)
-    input_mask = [1] * len(input_ids)
-    input_ids += [0] * (self._max_length - len(input_ids))
-    input_mask += [0] * (self._max_length - len(input_mask))
-    segment_ids += [0] * (self._max_length - len(segment_ids))
-    tf_example = tf.train.Example(features=tf.train.Features(feature={
-        "input_ids": create_int_feature(input_ids),
-        "input_mask": create_int_feature(input_mask),
-        "segment_ids": create_int_feature(segment_ids)
-    }))
-    return tf_example
-
-
-class ExampleWriter(object):
-  """Writes pre-training examples to disk."""
-
-  def __init__(self, job_id, vocab_file, output_dir, max_seq_length,
-               num_jobs, blanks_separate_docs, do_lower_case,
-               num_out_files=1000):
-    self._blanks_separate_docs = blanks_separate_docs
-    tokenizer = tokenization.FullTokenizer(
-        vocab_file=vocab_file,
-        do_lower_case=do_lower_case)
-    self._example_builder = ExampleBuilder(tokenizer, max_seq_length)
-    self._writers = []
-    for i in range(num_out_files):
-      if i % num_jobs == job_id:
-        output_fname = os.path.join(
-            output_dir, "pretrain_data.tfrecord-{:}-of-{:}".format(
-                i, num_out_files))
-        self._writers.append(tf.io.TFRecordWriter(output_fname))
-    self.n_written = 0
-
-  def write_examples(self, input_file):
-    """Writes out examples from the provided input file."""
-    with tf.io.gfile.GFile(input_file) as f:
-      for line in f:
-        line = line.strip()
-        if line or self._blanks_separate_docs:
-          example = self._example_builder.add_line(line)
-          if example:
-            self._writers[self.n_written % len(self._writers)].write(
-                example.SerializeToString())
-            self.n_written += 1
-      example = self._example_builder.add_line("")
-      if example:
-        self._writers[self.n_written % len(self._writers)].write(
-            example.SerializeToString())
-        self.n_written += 1
-
-  def finish(self):
-    for writer in self._writers:
-      writer.close()
-
-
-def write_examples(job_id, args):
-  """A single process creating and writing out pre-processed examples."""
-
-  def log(*args):
-    msg = " ".join(map(str, args))
-    print("Job {}:".format(job_id), msg)
-
-  log("Creating example writer")
-  example_writer = ExampleWriter(
-      job_id=job_id,
-      vocab_file=args.vocab_file,
-      output_dir=args.output_dir,
-      max_seq_length=args.max_seq_length,
-      num_jobs=args.num_processes,
-      blanks_separate_docs=args.blanks_separate_docs,
-      do_lower_case=args.do_lower_case
-  )
-  log("Writing tf examples")
-  fnames = sorted(tf.io.gfile.listdir(args.corpus_dir))
-  fnames = [f for (i, f) in enumerate(fnames)
-            if i % args.num_processes == job_id]
-  random.shuffle(fnames)
-  start_time = time.time()
-  for file_no, fname in enumerate(fnames):
-    if file_no > 0:
-      elapsed = time.time() - start_time
-      log("processed {:}/{:} files ({:.1f}%), ELAPSED: {:}s, ETA: {:}s, "
-          "{:} examples written".format(
-              file_no, len(fnames), 100.0 * file_no / len(fnames), int(elapsed),
-              int((len(fnames) - file_no) / (file_no / elapsed)),
-              example_writer.n_written))
-    example_writer.write_examples(os.path.join(args.corpus_dir, fname))
-  example_writer.finish()
-  log("Done!")
-
-
-def main():
-  parser = argparse.ArgumentParser(description=__doc__)
-  parser.add_argument("--corpus-dir", required=True,
-                      help="Location of pre-training text files.")
-  parser.add_argument("--vocab-file", required=True,
-                      help="Location of vocabulary file.")
-  parser.add_argument("--output-dir", required=True,
-                      help="Where to write out the tfrecords.")
-  parser.add_argument("--max-seq-length", default=128, type=int,
-                      help="Number of tokens per example.")
-  parser.add_argument("--num-processes", default=1, type=int,
-                      help="Parallelize across multiple processes.")
-  parser.add_argument("--blanks-separate-docs", default=True, type=bool,
-                      help="Whether blank lines indicate document boundaries.")
-  parser.add_argument("--do-lower-case", dest='do_lower_case',
-                      action='store_true', help="Lower case input text.")
-  parser.add_argument("--no-lower-case", dest='do_lower_case',
-                      action='store_false', help="Don't lower case input text.")
-  parser.set_defaults(do_lower_case=True)
-  args = parser.parse_args()
-
-  utils.rmkdir(args.output_dir)
-  if args.num_processes == 1:
-    write_examples(0, args)
-  else:
-    jobs = []
-    for i in range(args.num_processes):
-      job = multiprocessing.Process(target=write_examples, args=(i, args))
-      jobs.append(job)
-      job.start()
-    for job in jobs:
-      job.join()
-
-
-if __name__ == "__main__":
-  main()

sinatools/arabert/araelectra/build_pretraining_dataset_single_file.py

@@ -1,90 +0,0 @@
-# coding=utf-8
-
-import argparse
-import os
-import tensorflow as tf
-
-import build_pretraining_dataset
-from model import tokenization
-
-class ExampleWriter(object):
-  """Writes pre-training examples to disk."""
-
-  def __init__(self, input_fname, vocab_file, output_dir, max_seq_length,
-               blanks_separate_docs, do_lower_case):
-    self._blanks_separate_docs = blanks_separate_docs
-    tokenizer = tokenization.FullTokenizer(
-        vocab_file=vocab_file,
-        do_lower_case=do_lower_case)
-    self._example_builder = build_pretraining_dataset.ExampleBuilder(tokenizer, max_seq_length)
-    output_fname = os.path.join(output_dir, "{}.tfrecord".format(input_fname.split("/")[-1]))
-    self._writer = tf.io.TFRecordWriter(output_fname)
-    self.n_written = 0
-
-  def write_examples(self, input_file):
-    """Writes out examples from the provided input file."""
-    with tf.io.gfile.GFile(input_file) as f:
-      for line in f:
-        line = line.strip()
-        if line or self._blanks_separate_docs:
-          example = self._example_builder.add_line(line)
-          if example:
-            self._writer.write(example.SerializeToString())
-            self.n_written += 1
-      example = self._example_builder.add_line("")
-      if example:
-        self._writer.write(example.SerializeToString())
-        self.n_written += 1
-
-  def finish(self):
-    self._writer.close()
-
-def write_examples(args):
-  """A single process creating and writing out pre-processed examples."""
-
-  def log(*args):
-    msg = " ".join(map(str, args))
-    print(msg)
-
-  log("Creating example writer")
-  example_writer = ExampleWriter(
-      input_fname=args.input_file,
-      vocab_file=args.vocab_file,
-      output_dir=args.output_dir,
-      max_seq_length=args.max_seq_length,
-      blanks_separate_docs=args.blanks_separate_docs,
-      do_lower_case=args.do_lower_case
-  )
-  log("Writing tf example")
-
-  example_writer.write_examples(args.input_file)
-  example_writer.finish()
-  log("Done!")
-  return
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--input-file", required=True,
-                        help="Location of pre-training text files.")
-    parser.add_argument("--vocab-file", required=True,
-                        help="Location of vocabulary file.")
-    parser.add_argument("--output-dir", required=True,
-                        help="Where to write out the tfrecords.")
-    parser.add_argument("--max-seq-length", default=128, type=int,
-                        help="Number of tokens per example.")
-    parser.add_argument("--blanks-separate-docs", default=True, type=bool,
-                        help="Whether blank lines indicate document boundaries.")
-    parser.add_argument("--do-lower-case", dest='do_lower_case',
-                        action='store_true', help="Lower case input text.")
-    parser.add_argument("--no-lower-case", dest='do_lower_case',
-                        action='store_false', help="Don't lower case input text.")
-    parser.set_defaults(do_lower_case=True)
-    args = parser.parse_args()
-
-    write_examples(args)
-
-
-
-if __name__ == "__main__":
-  main()

sinatools/arabert/araelectra/configure_finetuning.py

@@ -1,172 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The Google Research Authors.
-#
-# 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.
-
-"""Config controlling hyperparameters for fine-tuning ELECTRA."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-
-import tensorflow as tf
-
-
-class FinetuningConfig(object):
-  """Fine-tuning hyperparameters."""
-
-  def __init__(self, model_name, data_dir, **kwargs):
-    # general
-    self.model_name = model_name
-    self.debug = False  # debug mode for quickly running things
-    self.log_examples = False  # print out some train examples for debugging
-    self.num_trials = 1  # how many train+eval runs to perform
-    self.do_train = True  # train a model
-    self.do_eval = True  # evaluate the model
-    self.keep_all_models = True  # if False, only keep the last trial's ckpt
-
-    # model
-    self.model_size = "base"  # one of "small", "base", or "large"
-    self.task_names = ["chunk"]  # which tasks to learn
-    # override the default transformer hparams for the provided model size; see
-    # modeling.BertConfig for the possible hparams and util.training_utils for
-    # the defaults
-    self.model_hparam_overrides = (
-        kwargs["model_hparam_overrides"]
-        if "model_hparam_overrides" in kwargs else {})
-    self.embedding_size = None  # bert hidden size by default
-    self.vocab_size = 64000  # number of tokens in the vocabulary
-    self.do_lower_case = True
-
-    # training
-    self.learning_rate = 1e-4
-    self.weight_decay_rate = 0.01
-    self.layerwise_lr_decay = 0.8  # if > 0, the learning rate for a layer is
-                                   # lr * lr_decay^(depth - max_depth) i.e.,
-                                   # shallower layers have lower learning rates
-    self.num_train_epochs = 3.0  # passes over the dataset during training
-    self.warmup_proportion = 0.1  # how much of training to warm up the LR for
-    self.save_checkpoints_steps = 1000000
-    self.iterations_per_loop = 1000
-    self.use_tfrecords_if_existing = True  # don't make tfrecords and write them
-                                           # to disc if existing ones are found
-
-    # writing model outputs to disc
-    self.write_test_outputs = False  # whether to write test set outputs,
-                                     # currently supported for GLUE + SQuAD 2.0
-    self.n_writes_test = 5  # write test set predictions for the first n trials
-
-    # sizing
-    self.max_seq_length = 128
-    self.train_batch_size = 32
-    self.eval_batch_size = 32
-    self.predict_batch_size = 32
-    self.double_unordered = True  # for tasks like paraphrase where sentence
-                                  # order doesn't matter, train the model on
-                                  # on both sentence orderings for each example
-    # for qa tasks
-    self.max_query_length = 64   # max tokens in q as opposed to context
-    self.doc_stride = 128  # stride when splitting doc into multiple examples
-    self.n_best_size = 20  # number of predictions per example to save
-    self.max_answer_length = 30  # filter out answers longer than this length
-    self.answerable_classifier = True  # answerable classifier for SQuAD 2.0
-    self.answerable_uses_start_logits = True  # more advanced answerable
-                                              # classifier using predicted start
-    self.answerable_weight = 0.5  # weight for answerability loss
-    self.joint_prediction = True  # jointly predict the start and end positions
-                                  # of the answer span
-    self.beam_size = 20  # beam size when doing joint predictions
-    self.qa_na_threshold = -2.75  # threshold for "no answer" when writing SQuAD
-                                  # 2.0 test outputs
-
-    # TPU settings
-    self.use_tpu = False
-    self.num_tpu_cores = 1
-    self.tpu_job_name = None
-    self.tpu_name = None  # cloud TPU to use for training
-    self.tpu_zone = None  # GCE zone where the Cloud TPU is located in
-    self.gcp_project = None  # project name for the Cloud TPU-enabled project
-
-    # default locations of data files
-    self.data_dir = data_dir
-    pretrained_model_dir = os.path.join(data_dir, "models", model_name)
-    self.raw_data_dir = os.path.join(data_dir, "finetuning_data", "{:}").format
-    self.vocab_file = os.path.join(pretrained_model_dir, "vocab.txt")
-    if not tf.io.gfile.exists(self.vocab_file):
-      self.vocab_file = os.path.join(self.data_dir, "vocab.txt")
-    task_names_str = ",".join(
-        kwargs["task_names"] if "task_names" in kwargs else self.task_names)
-    self.init_checkpoint = None if self.debug else pretrained_model_dir
-    self.model_dir = os.path.join(pretrained_model_dir, "finetuning_models",
-                                  task_names_str + "_model")
-    results_dir = os.path.join(pretrained_model_dir, "results")
-    self.results_txt = os.path.join(results_dir,
-                                    task_names_str + "_results.txt")
-    self.results_pkl = os.path.join(results_dir,
-                                    task_names_str + "_results.pkl")
-    qa_topdir = os.path.join(results_dir, task_names_str + "_qa")
-    self.qa_eval_file = os.path.join(qa_topdir, "{:}_eval.json").format
-    self.qa_preds_file = os.path.join(qa_topdir, "{:}_preds.json").format
-    self.qa_na_file = os.path.join(qa_topdir, "{:}_null_odds.json").format
-    self.preprocessed_data_dir = os.path.join(
-        pretrained_model_dir, "finetuning_tfrecords",
-        task_names_str + "_tfrecords" + ("-debug" if self.debug else ""))
-    self.test_predictions = os.path.join(
-        pretrained_model_dir, "test_predictions",
-        "{:}_{:}_{:}_predictions.pkl").format
-
-    # update defaults with passed-in hyperparameters
-    self.update(kwargs)
-
-    # default hyperparameters for single-task models
-    if len(self.task_names) == 1:
-      task_name = self.task_names[0]
-      if task_name == "rte" or task_name == "sts":
-        self.num_train_epochs = 10.0
-      elif "squad" in task_name or "qa" in task_name:
-        self.max_seq_length = 512
-        self.num_train_epochs = 2.0
-        self.write_distill_outputs = False
-        self.write_test_outputs = False
-      elif task_name == "chunk":
-        self.max_seq_length = 256
-      else:
-        self.num_train_epochs = 3.0
-
-    # default hyperparameters for different model sizes
-    if self.model_size == "large":
-      self.learning_rate = 5e-5
-      self.layerwise_lr_decay = 0.9
-    elif self.model_size == "small":
-      self.embedding_size = 128
-
-    # debug-mode settings
-    if self.debug:
-      self.save_checkpoints_steps = 1000000
-      self.use_tfrecords_if_existing = False
-      self.num_trials = 1
-      self.iterations_per_loop = 1
-      self.train_batch_size = 32
-      self.num_train_epochs = 3.0
-      self.log_examples = True
-
-    # passed-in-arguments override (for example) debug-mode defaults
-    self.update(kwargs)
-
-  def update(self, kwargs):
-    for k, v in kwargs.items():
-      if k not in self.__dict__:
-        raise ValueError("Unknown hparam " + k)
-      self.__dict__[k] = v

sinatools/arabert/araelectra/configure_pretraining.py

@@ -1,143 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The Google Research Authors.
-#
-# 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.
-
-"""Config controlling hyperparameters for pre-training ELECTRA."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-
-
-class PretrainingConfig(object):
-  """Defines pre-training hyperparameters."""
-
-  def __init__(self, model_name, data_dir, **kwargs):
-    self.model_name = model_name
-    self.debug = False  # debug mode for quickly running things
-    self.do_train = True  # pre-train ELECTRA
-    self.do_eval = False  # evaluate generator/discriminator on unlabeled data
-
-    # loss functions
-    # train ELECTRA or Electric? if both are false, trains a masked LM like BERT
-    self.electra_objective = True
-    self.electric_objective = False
-    self.gen_weight = 1.0  # masked language modeling / generator loss
-    self.disc_weight = 50.0  # discriminator loss
-    self.mask_prob = 0.15  # percent of input tokens to mask out / replace
-
-    # optimization
-    self.learning_rate = 2e-4
-    self.lr_decay_power = 1.0  # linear weight decay by default
-    self.weight_decay_rate = 0.01
-    self.num_warmup_steps = 10000
-
-    # training settings
-    self.iterations_per_loop = 5000
-    self.save_checkpoints_steps = 25000
-    self.num_train_steps = 2000000
-    self.num_eval_steps = 10000
-    self.keep_checkpoint_max = 0 # maximum number of recent checkpoint files to keep;
-                                 # change to 0 or None to keep all checkpoints
-
-    # model settings
-    self.model_size = "base"  # one of "small", "base", or "large"
-    # override the default transformer hparams for the provided model size; see
-    # modeling.BertConfig for the possible hparams and util.training_utils for
-    # the defaults
-    self.model_hparam_overrides = (
-        kwargs["model_hparam_overrides"]
-        if "model_hparam_overrides" in kwargs else {})
-    self.embedding_size = None  # bert hidden size by default
-    self.vocab_size = 64000  # number of tokens in the vocabulary
-    self.do_lower_case = False  # lowercase the input?
-
-    # generator settings
-    self.uniform_generator = False  # generator is uniform at random
-    self.two_tower_generator = False  # generator is a two-tower cloze model
-    self.untied_generator_embeddings = False  # tie generator/discriminator
-                                              # token embeddings?
-    self.untied_generator = True  # tie all generator/discriminator weights?
-    self.generator_layers = 1.0  # frac of discriminator layers for generator
-    self.generator_hidden_size = 0.25  # frac of discrim hidden size for gen
-    self.disallow_correct = False  # force the generator to sample incorrect
-                                   # tokens (so 15% of tokens are always
-                                   # fake)
-    self.temperature = 1.0  # temperature for sampling from generator
-
-    # batch sizes
-    self.max_seq_length = 512
-    self.train_batch_size = 256
-    self.eval_batch_size = 256
-
-    # TPU settings
-    self.use_tpu = True
-    self.num_tpu_cores = 8
-    self.tpu_job_name = None
-    self.tpu_name = ""  # cloud TPU to use for training
-    self.tpu_zone = ""  # GCE zone where the Cloud TPU is located in
-    self.gcp_project = ""  # project name for the Cloud TPU-enabled project
-
-    # default locations of data files
-    self.pretrain_tfrecords = os.path.join(
-        data_dir, "pretraining_data/512/*")
-    self.vocab_file = os.path.join(data_dir, "bertvocab_final.txt")
-    self.model_dir = os.path.join(data_dir, "models", model_name)
-    results_dir = os.path.join(self.model_dir, "results")
-    self.results_txt = os.path.join(results_dir, "unsup_results.txt")
-    self.results_pkl = os.path.join(results_dir, "unsup_results.pkl")
-
-    # update defaults with passed-in hyperparameters
-    self.update(kwargs)
-
-    self.max_predictions_per_seq = int((self.mask_prob + 0.005) *
-                                       self.max_seq_length)
-
-    # debug-mode settings
-    if self.debug:
-      self.train_batch_size = 8
-      self.num_train_steps = 20
-      self.eval_batch_size = 4
-      self.iterations_per_loop = 1
-      self.num_eval_steps = 2
-
-    # defaults for different-sized model
-    if self.model_size == "small":
-      self.embedding_size = 128
-    # Here are the hyperparameters we used for larger models; see Table 6 in the
-    # paper for the full hyperparameters
-    else:
-      self.max_seq_length = 512
-      self.learning_rate = 2e-4
-      if self.model_size == "base":
-        self.embedding_size = 768
-        self.generator_hidden_size = 0.33333
-        self.train_batch_size = 256
-      else:
-        self.embedding_size = 1024
-        self.mask_prob = 0.25
-        self.train_batch_size = 2048
-    if self.electric_objective:
-      self.two_tower_generator = True  # electric requires a two-tower generator
-
-    # passed-in-arguments override (for example) debug-mode defaults
-    self.update(kwargs)
-
-  def update(self, kwargs):
-    for k, v in kwargs.items():
-      if k not in self.__dict__:
-        raise ValueError("Unknown hparam " + k)
-      self.__dict__[k] = v

sinatools/arabert/araelectra/finetune/__init__.py

@@ -1,14 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The Google Research Authors.
-#
-# 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.